/export/starexec/sandbox2/solver/bin/starexec_run_complexity /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


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


WORST_CASE(Omega(n^2), O(n^2))
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^2, n^2).

(0) CpxRelTRS
(1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 177 ms]
(2) CpxRelTRS
(3) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(4) CpxWeightedTrs
    (5) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (6) CpxTypedWeightedTrs
    (7) CompletionProof [UPPER BOUND(ID), 0 ms]
    (8) CpxTypedWeightedCompleteTrs
    (9) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxTypedWeightedCompleteTrs
    (11) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
    (12) CpxRNTS
    (13) InliningProof [UPPER BOUND(ID), 1059 ms]
    (14) CpxRNTS
    (15) SimplificationProof [BOTH BOUNDS(ID, ID), 11 ms]
    (16) CpxRNTS
    (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
    (18) CpxRNTS
    (19) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (20) CpxRNTS
    (21) IntTrsBoundProof [UPPER BOUND(ID), 649 ms]
    (22) CpxRNTS
    (23) IntTrsBoundProof [UPPER BOUND(ID), 193 ms]
    (24) CpxRNTS
    (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (26) CpxRNTS
    (27) IntTrsBoundProof [UPPER BOUND(ID), 379 ms]
    (28) CpxRNTS
    (29) IntTrsBoundProof [UPPER BOUND(ID), 84 ms]
    (30) CpxRNTS
    (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (32) CpxRNTS
    (33) IntTrsBoundProof [UPPER BOUND(ID), 289 ms]
    (34) CpxRNTS
    (35) IntTrsBoundProof [UPPER BOUND(ID), 82 ms]
    (36) CpxRNTS
    (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (38) CpxRNTS
    (39) IntTrsBoundProof [UPPER BOUND(ID), 1053 ms]
    (40) CpxRNTS
    (41) IntTrsBoundProof [UPPER BOUND(ID), 225 ms]
    (42) CpxRNTS
    (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (44) CpxRNTS
    (45) IntTrsBoundProof [UPPER BOUND(ID), 187 ms]
    (46) CpxRNTS
    (47) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
    (48) CpxRNTS
    (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (50) CpxRNTS
    (51) IntTrsBoundProof [UPPER BOUND(ID), 528 ms]
    (52) CpxRNTS
    (53) IntTrsBoundProof [UPPER BOUND(ID), 217 ms]
    (54) CpxRNTS
    (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (56) CpxRNTS
    (57) IntTrsBoundProof [UPPER BOUND(ID), 166 ms]
    (58) CpxRNTS
    (59) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
    (60) CpxRNTS
    (61) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (62) CpxRNTS
    (63) IntTrsBoundProof [UPPER BOUND(ID), 209 ms]
    (64) CpxRNTS
    (65) IntTrsBoundProof [UPPER BOUND(ID), 62 ms]
    (66) CpxRNTS
    (67) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (68) CpxRNTS
    (69) IntTrsBoundProof [UPPER BOUND(ID), 247 ms]
    (70) CpxRNTS
    (71) IntTrsBoundProof [UPPER BOUND(ID), 22 ms]
    (72) CpxRNTS
    (73) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (74) CpxRNTS
    (75) IntTrsBoundProof [UPPER BOUND(ID), 575 ms]
    (76) CpxRNTS
    (77) IntTrsBoundProof [UPPER BOUND(ID), 47 ms]
    (78) CpxRNTS
    (79) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (80) CpxRNTS
    (81) IntTrsBoundProof [UPPER BOUND(ID), 421 ms]
    (82) CpxRNTS
    (83) IntTrsBoundProof [UPPER BOUND(ID), 65 ms]
    (84) CpxRNTS
    (85) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (86) CpxRNTS
    (87) IntTrsBoundProof [UPPER BOUND(ID), 288 ms]
    (88) CpxRNTS
    (89) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
    (90) CpxRNTS
    (91) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (92) CpxRNTS
    (93) IntTrsBoundProof [UPPER BOUND(ID), 378 ms]
    (94) CpxRNTS
    (95) IntTrsBoundProof [UPPER BOUND(ID), 123 ms]
    (96) CpxRNTS
    (97) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (98) CpxRNTS
    (99) IntTrsBoundProof [UPPER BOUND(ID), 176 ms]
    (100) CpxRNTS
    (101) IntTrsBoundProof [UPPER BOUND(ID), 63 ms]
    (102) CpxRNTS
    (103) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (104) CpxRNTS
    (105) IntTrsBoundProof [UPPER BOUND(ID), 648 ms]
    (106) CpxRNTS
    (107) IntTrsBoundProof [UPPER BOUND(ID), 245 ms]
    (108) CpxRNTS
    (109) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (110) CpxRNTS
    (111) IntTrsBoundProof [UPPER BOUND(ID), 1079 ms]
    (112) CpxRNTS
    (113) IntTrsBoundProof [UPPER BOUND(ID), 668 ms]
    (114) CpxRNTS
    (115) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (116) CpxRNTS
    (117) IntTrsBoundProof [UPPER BOUND(ID), 157 ms]
    (118) CpxRNTS
    (119) IntTrsBoundProof [UPPER BOUND(ID), 63 ms]
    (120) CpxRNTS
    (121) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (122) CpxRNTS
    (123) IntTrsBoundProof [UPPER BOUND(ID), 125 ms]
    (124) CpxRNTS
    (125) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (126) CpxRNTS
    (127) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (128) CpxRNTS
    (129) IntTrsBoundProof [UPPER BOUND(ID), 117 ms]
    (130) CpxRNTS
    (131) IntTrsBoundProof [UPPER BOUND(ID), 1 ms]
    (132) CpxRNTS
    (133) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (134) CpxRNTS
    (135) IntTrsBoundProof [UPPER BOUND(ID), 288 ms]
    (136) CpxRNTS
    (137) IntTrsBoundProof [UPPER BOUND(ID), 44 ms]
    (138) CpxRNTS
    (139) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (140) CpxRNTS
    (141) IntTrsBoundProof [UPPER BOUND(ID), 188 ms]
    (142) CpxRNTS
    (143) IntTrsBoundProof [UPPER BOUND(ID), 2 ms]
    (144) CpxRNTS
    (145) FinalProof [FINISHED, 0 ms]
    (146) BOUNDS(1, n^2)
(147) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(148) CpxRelTRS
    (149) SlicingProof [LOWER BOUND(ID), 0 ms]
    (150) CpxRelTRS
    (151) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) typed CpxTrs
    (153) OrderProof [LOWER BOUND(ID), 0 ms]
    (154) typed CpxTrs
    (155) RewriteLemmaProof [LOWER BOUND(ID), 1952 ms]
    (156) typed CpxTrs
    (157) RewriteLemmaProof [LOWER BOUND(ID), 177 ms]
    (158) BEST
        (159) proven lower bound
            (160) LowerBoundPropagationProof [FINISHED, 0 ms]
            (161) BOUNDS(n^1, INF)
        (162) typed CpxTrs
            (163) RewriteLemmaProof [LOWER BOUND(ID), 154 ms]
            (164) typed CpxTrs
            (165) RewriteLemmaProof [LOWER BOUND(ID), 49 ms]
            (166) typed CpxTrs
            (167) RewriteLemmaProof [LOWER BOUND(ID), 56 ms]
            (168) BEST
                (169) proven lower bound
                    (170) LowerBoundPropagationProof [FINISHED, 0 ms]
                    (171) BOUNDS(n^2, INF)
                (172) typed CpxTrs
                    (173) RewriteLemmaProof [LOWER BOUND(ID), 45 ms]
                    (174) typed CpxTrs
                    (175) RewriteLemmaProof [LOWER BOUND(ID), 87 ms]
                    (176) typed CpxTrs


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

(0)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^2, n^2).


The TRS R consists of the following rules:

   #abs(#0) -> #0
   #abs(#neg(@x)) -> #pos(@x)
   #abs(#pos(@x)) -> #pos(@x)
   #abs(#s(@x)) -> #pos(#s(@x))
   #greater(@x, @y) -> #ckgt(#compare(@x, @y))
   append(@l, @ys) -> append#1(@l, @ys)
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
   append#1(nil, @ys) -> @ys
   appendD(@l, @ys) -> appendD#1(@l, @ys)
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
   appendD#1(nil, @ys) -> @ys
   quicksort(@l) -> quicksort#1(@l)
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
   quicksort#1(nil) -> nil
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
   quicksortD(@l) -> quicksortD#1(@l)
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
   quicksortD#1(nil) -> nil
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
   split(@pivot, @l) -> split#1(@l, @pivot)
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
   split#1(nil, @pivot) -> tuple#2(nil, nil)
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   splitD(@pivot, @l) -> splitD#1(@l, @pivot)
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
   splitD#1(nil, @pivot) -> tuple#2(nil, nil)
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
   testQuicksort(@x) -> quicksort(testList(#unit))
   testQuicksort2(@x) -> quicksort(testList(#unit))

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

   #ckgt(#EQ) -> #false
   #ckgt(#GT) -> #true
   #ckgt(#LT) -> #false
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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

(1) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID))
proved innermost termination of relative rules
----------------------------------------

(2)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^2, n^2).


The TRS R consists of the following rules:

   #abs(#0) -> #0
   #abs(#neg(@x)) -> #pos(@x)
   #abs(#pos(@x)) -> #pos(@x)
   #abs(#s(@x)) -> #pos(#s(@x))
   #greater(@x, @y) -> #ckgt(#compare(@x, @y))
   append(@l, @ys) -> append#1(@l, @ys)
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
   append#1(nil, @ys) -> @ys
   appendD(@l, @ys) -> appendD#1(@l, @ys)
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
   appendD#1(nil, @ys) -> @ys
   quicksort(@l) -> quicksort#1(@l)
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
   quicksort#1(nil) -> nil
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
   quicksortD(@l) -> quicksortD#1(@l)
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
   quicksortD#1(nil) -> nil
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
   split(@pivot, @l) -> split#1(@l, @pivot)
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
   split#1(nil, @pivot) -> tuple#2(nil, nil)
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   splitD(@pivot, @l) -> splitD#1(@l, @pivot)
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
   splitD#1(nil, @pivot) -> tuple#2(nil, nil)
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
   testQuicksort(@x) -> quicksort(testList(#unit))
   testQuicksort2(@x) -> quicksort(testList(#unit))

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

   #ckgt(#EQ) -> #false
   #ckgt(#GT) -> #true
   #ckgt(#LT) -> #false
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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

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

(4)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, n^2).


The TRS R consists of the following rules:

   #abs(#0) -> #0 [1]
   #abs(#neg(@x)) -> #pos(@x) [1]
   #abs(#pos(@x)) -> #pos(@x) [1]
   #abs(#s(@x)) -> #pos(#s(@x)) [1]
   #greater(@x, @y) -> #ckgt(#compare(@x, @y)) [1]
   append(@l, @ys) -> append#1(@l, @ys) [1]
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys)) [1]
   append#1(nil, @ys) -> @ys [1]
   appendD(@l, @ys) -> appendD#1(@l, @ys) [1]
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys)) [1]
   appendD#1(nil, @ys) -> @ys [1]
   quicksort(@l) -> quicksort#1(@l) [1]
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z) [1]
   quicksort#1(nil) -> nil [1]
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys))) [1]
   quicksortD(@l) -> quicksortD#1(@l) [1]
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z) [1]
   quicksortD#1(nil) -> nil [1]
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys))) [1]
   split(@pivot, @l) -> split#1(@l, @pivot) [1]
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x) [1]
   split#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x) [1]
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   splitD(@pivot, @l) -> splitD#1(@l, @pivot) [1]
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x) [1]
   splitD#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x) [1]
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil)))))))))) [1]
   testQuicksort(@x) -> quicksort(testList(#unit)) [1]
   testQuicksort2(@x) -> quicksort(testList(#unit)) [1]
   #ckgt(#EQ) -> #false [0]
   #ckgt(#GT) -> #true [0]
   #ckgt(#LT) -> #false [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]

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

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

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

   #abs(#0) -> #0 [1]
   #abs(#neg(@x)) -> #pos(@x) [1]
   #abs(#pos(@x)) -> #pos(@x) [1]
   #abs(#s(@x)) -> #pos(#s(@x)) [1]
   #greater(@x, @y) -> #ckgt(#compare(@x, @y)) [1]
   append(@l, @ys) -> append#1(@l, @ys) [1]
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys)) [1]
   append#1(nil, @ys) -> @ys [1]
   appendD(@l, @ys) -> appendD#1(@l, @ys) [1]
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys)) [1]
   appendD#1(nil, @ys) -> @ys [1]
   quicksort(@l) -> quicksort#1(@l) [1]
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z) [1]
   quicksort#1(nil) -> nil [1]
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys))) [1]
   quicksortD(@l) -> quicksortD#1(@l) [1]
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z) [1]
   quicksortD#1(nil) -> nil [1]
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys))) [1]
   split(@pivot, @l) -> split#1(@l, @pivot) [1]
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x) [1]
   split#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x) [1]
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   splitD(@pivot, @l) -> splitD#1(@l, @pivot) [1]
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x) [1]
   splitD#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x) [1]
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil)))))))))) [1]
   testQuicksort(@x) -> quicksort(testList(#unit)) [1]
   testQuicksort2(@x) -> quicksort(testList(#unit)) [1]
   #ckgt(#EQ) -> #false [0]
   #ckgt(#GT) -> #true [0]
   #ckgt(#LT) -> #false [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]

The TRS has the following type information:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: #unit -> :::nil
testQuicksort :: a -> :::nil
#unit :: #unit
testQuicksort2 :: b -> :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT

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

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

   testQuicksort_1
   testQuicksort2_1

(c) The following functions are completely defined:

   testList_1
   quicksort_1
   splitD_2
   quicksortD_1
   #greater_2
   split_2
   split#1_2
   #abs_1
   quicksortD#1_1
   splitD#1_2
   split#2_3
   quicksort#1_1
   quicksortD#2_2
   appendD_2
   quicksort#2_2
   splitD#2_3
   appendD#1_2
   split#3_4
   append_2
   splitD#3_4
   append#1_2
   #ckgt_1
   #compare_2

Due to the following rules being added:

   #ckgt(v0) -> null_#ckgt [0]
   #compare(v0, v1) -> null_#compare [0]
   split#2(v0, v1, v2) -> const [0]
   quicksortD#2(v0, v1) -> nil [0]
   quicksort#2(v0, v1) -> nil [0]
   splitD#2(v0, v1, v2) -> const [0]
   split#3(v0, v1, v2, v3) -> const [0]
   splitD#3(v0, v1, v2, v3) -> const [0]

And the following fresh constants:    null_#ckgt, null_#compare, const, const1, const2

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

(8)
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:

   #abs(#0) -> #0 [1]
   #abs(#neg(@x)) -> #pos(@x) [1]
   #abs(#pos(@x)) -> #pos(@x) [1]
   #abs(#s(@x)) -> #pos(#s(@x)) [1]
   #greater(@x, @y) -> #ckgt(#compare(@x, @y)) [1]
   append(@l, @ys) -> append#1(@l, @ys) [1]
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys)) [1]
   append#1(nil, @ys) -> @ys [1]
   appendD(@l, @ys) -> appendD#1(@l, @ys) [1]
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys)) [1]
   appendD#1(nil, @ys) -> @ys [1]
   quicksort(@l) -> quicksort#1(@l) [1]
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z) [1]
   quicksort#1(nil) -> nil [1]
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys))) [1]
   quicksortD(@l) -> quicksortD#1(@l) [1]
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z) [1]
   quicksortD#1(nil) -> nil [1]
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys))) [1]
   split(@pivot, @l) -> split#1(@l, @pivot) [1]
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x) [1]
   split#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x) [1]
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   splitD(@pivot, @l) -> splitD#1(@l, @pivot) [1]
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x) [1]
   splitD#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x) [1]
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil)))))))))) [1]
   testQuicksort(@x) -> quicksort(testList(#unit)) [1]
   testQuicksort2(@x) -> quicksort(testList(#unit)) [1]
   #ckgt(#EQ) -> #false [0]
   #ckgt(#GT) -> #true [0]
   #ckgt(#LT) -> #false [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]
   #ckgt(v0) -> null_#ckgt [0]
   #compare(v0, v1) -> null_#compare [0]
   split#2(v0, v1, v2) -> const [0]
   quicksortD#2(v0, v1) -> nil [0]
   quicksort#2(v0, v1) -> nil [0]
   splitD#2(v0, v1, v2) -> const [0]
   split#3(v0, v1, v2, v3) -> const [0]
   splitD#3(v0, v1, v2, v3) -> const [0]

The TRS has the following type information:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#ckgt
#ckgt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#ckgt
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2:const -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2:const
tuple#2 :: :::nil -> :::nil -> tuple#2:const
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2:const -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2:const
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const
split#2 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const
split#3 :: #false:#true:null_#ckgt -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2:const
#false :: #false:#true:null_#ckgt
#true :: #false:#true:null_#ckgt
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const
splitD#2 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const
splitD#3 :: #false:#true:null_#ckgt -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2:const
testList :: #unit -> :::nil
testQuicksort :: a -> :::nil
#unit :: #unit
testQuicksort2 :: b -> :::nil
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
null_#ckgt :: #false:#true:null_#ckgt
null_#compare :: #EQ:#GT:#LT:null_#compare
const :: tuple#2:const
const1 :: a
const2 :: b

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

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

(10)
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:

   #abs(#0) -> #0 [1]
   #abs(#neg(@x)) -> #pos(@x) [1]
   #abs(#pos(@x)) -> #pos(@x) [1]
   #abs(#s(@x)) -> #pos(#s(@x)) [1]
   #greater(#0, #0) -> #ckgt(#EQ) [1]
   #greater(#0, #neg(@y')) -> #ckgt(#GT) [1]
   #greater(#0, #pos(@y'')) -> #ckgt(#LT) [1]
   #greater(#0, #s(@y1)) -> #ckgt(#LT) [1]
   #greater(#neg(@x'), #0) -> #ckgt(#LT) [1]
   #greater(#neg(@x''), #neg(@y2)) -> #ckgt(#compare(@y2, @x'')) [1]
   #greater(#neg(@x1), #pos(@y3)) -> #ckgt(#LT) [1]
   #greater(#pos(@x2), #0) -> #ckgt(#GT) [1]
   #greater(#pos(@x3), #neg(@y4)) -> #ckgt(#GT) [1]
   #greater(#pos(@x4), #pos(@y5)) -> #ckgt(#compare(@x4, @y5)) [1]
   #greater(#s(@x5), #0) -> #ckgt(#GT) [1]
   #greater(#s(@x6), #s(@y6)) -> #ckgt(#compare(@x6, @y6)) [1]
   #greater(@x, @y) -> #ckgt(null_#compare) [1]
   append(@l, @ys) -> append#1(@l, @ys) [1]
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys)) [1]
   append#1(nil, @ys) -> @ys [1]
   appendD(@l, @ys) -> appendD#1(@l, @ys) [1]
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys)) [1]
   appendD#1(nil, @ys) -> @ys [1]
   quicksort(@l) -> quicksort#1(@l) [1]
   quicksort#1(::(@z, @zs)) -> quicksort#2(split#1(@zs, @z), @z) [2]
   quicksort#1(nil) -> nil [1]
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort#1(@xs), ::(@z, quicksort#1(@ys))) [3]
   quicksortD(@l) -> quicksortD#1(@l) [1]
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD#1(@zs, @z), @z) [2]
   quicksortD#1(nil) -> nil [1]
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD#1(@xs), ::(@z, quicksortD#1(@ys))) [3]
   split(@pivot, @l) -> split#1(@l, @pivot) [1]
   split#1(::(@x, @xs), @pivot) -> split#2(split#1(@xs, @pivot), @pivot, @x) [2]
   split#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#ckgt(#compare(@x, @pivot)), @ls, @rs, @x) [2]
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   splitD(@pivot, @l) -> splitD#1(@l, @pivot) [1]
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD#1(@xs, @pivot), @pivot, @x) [2]
   splitD#1(nil, @pivot) -> tuple#2(nil, nil) [1]
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#ckgt(#compare(@x, @pivot)), @ls, @rs, @x) [2]
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs) [1]
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) [1]
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil)))))))))) [1]
   testQuicksort(@x) -> quicksort(::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))) [2]
   testQuicksort2(@x) -> quicksort(::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))) [2]
   #ckgt(#EQ) -> #false [0]
   #ckgt(#GT) -> #true [0]
   #ckgt(#LT) -> #false [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]
   #ckgt(v0) -> null_#ckgt [0]
   #compare(v0, v1) -> null_#compare [0]
   split#2(v0, v1, v2) -> const [0]
   quicksortD#2(v0, v1) -> nil [0]
   quicksort#2(v0, v1) -> nil [0]
   splitD#2(v0, v1, v2) -> const [0]
   split#3(v0, v1, v2, v3) -> const [0]
   splitD#3(v0, v1, v2, v3) -> const [0]

The TRS has the following type information:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#ckgt
#ckgt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#ckgt
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2:const -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2:const
tuple#2 :: :::nil -> :::nil -> tuple#2:const
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2:const -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2:const
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const
split#2 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const
split#3 :: #false:#true:null_#ckgt -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2:const
#false :: #false:#true:null_#ckgt
#true :: #false:#true:null_#ckgt
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const
splitD#2 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const
splitD#3 :: #false:#true:null_#ckgt -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2:const
testList :: #unit -> :::nil
testQuicksort :: a -> :::nil
#unit :: #unit
testQuicksort2 :: b -> :::nil
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
null_#ckgt :: #false:#true:null_#ckgt
null_#compare :: #EQ:#GT:#LT:null_#compare
const :: tuple#2:const
const1 :: a
const2 :: b

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

(11) 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
   nil => 0
   #false => 1
   #true => 2
   #unit => 0
   #EQ => 1
   #GT => 2
   #LT => 3
   null_#ckgt => 0
   null_#compare => 0
   const => 0
   const1 => 0
   const2 => 0

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + @x :|: @x >= 0, z = 1 + @x
   #abs(z) -{ 1 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + @x
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #greater(z, z') -{ 1 }-> #ckgt(3) :|: z' = 1 + @y'', @y'' >= 0, z = 0
   #greater(z, z') -{ 1 }-> #ckgt(3) :|: z' = 1 + @y1, @y1 >= 0, z = 0
   #greater(z, z') -{ 1 }-> #ckgt(3) :|: z = 1 + @x', @x' >= 0, z' = 0
   #greater(z, z') -{ 1 }-> #ckgt(3) :|: @y3 >= 0, @x1 >= 0, z' = 1 + @y3, z = 1 + @x1
   #greater(z, z') -{ 1 }-> #ckgt(2) :|: @y' >= 0, z' = 1 + @y', z = 0
   #greater(z, z') -{ 1 }-> #ckgt(2) :|: @x2 >= 0, z = 1 + @x2, z' = 0
   #greater(z, z') -{ 1 }-> #ckgt(2) :|: @x3 >= 0, z' = 1 + @y4, z = 1 + @x3, @y4 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(2) :|: z = 1 + @x5, @x5 >= 0, z' = 0
   #greater(z, z') -{ 1 }-> #ckgt(1) :|: z = 0, z' = 0
   #greater(z, z') -{ 1 }-> #ckgt(0) :|: z = @x, @x >= 0, z' = @y, @y >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(@x4, @y5)) :|: z' = 1 + @y5, @y5 >= 0, z = 1 + @x4, @x4 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(@x6, @y6)) :|: z = 1 + @x6, z' = 1 + @y6, @x6 >= 0, @y6 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(@y2, @x'')) :|: z = 1 + @x'', z' = 1 + @y2, @y2 >= 0, @x'' >= 0
   append(z, z') -{ 1 }-> append#1(@l, @ys) :|: z = @l, @l >= 0, z' = @ys, @ys >= 0
   append#1(z, z') -{ 1 }-> @ys :|: z' = @ys, z = 0, @ys >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, @ys) :|: z' = @ys, @x >= 0, z = 1 + @x + @xs, @xs >= 0, @ys >= 0
   appendD(z, z') -{ 1 }-> appendD#1(@l, @ys) :|: z = @l, @l >= 0, z' = @ys, @ys >= 0
   appendD#1(z, z') -{ 1 }-> @ys :|: z' = @ys, z = 0, @ys >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, @ys) :|: z' = @ys, @x >= 0, z = 1 + @x + @xs, @xs >= 0, @ys >= 0
   quicksort(z) -{ 1 }-> quicksort#1(@l) :|: z = @l, @l >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + @z + quicksort#1(@ys)) :|: z' = @z, z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, @z >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   quicksortD(z) -{ 1 }-> quicksortD#1(@l) :|: z = @l, @l >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + @z + quicksortD#1(@ys)) :|: z' = @z, z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, @z >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   split(z, z') -{ 1 }-> split#1(@l, @pivot) :|: @l >= 0, z = @pivot, z' = @l, @pivot >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, @pivot), @pivot, @x) :|: @x >= 0, z = 1 + @x + @xs, z' = @pivot, @xs >= 0, @pivot >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' = @pivot, @pivot >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(@x, @pivot)), @ls, @rs, @x) :|: @ls >= 0, z = 1 + @ls + @rs, @x >= 0, z' = @pivot, @pivot >= 0, z'' = @x, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + @ls + (1 + @x + @rs) :|: z = 2, z1 = @x, @ls >= 0, @x >= 0, z' = @ls, @rs >= 0, z'' = @rs
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + @x + @ls) + @rs :|: z1 = @x, @ls >= 0, @x >= 0, z = 1, z' = @ls, @rs >= 0, z'' = @rs
   splitD(z, z') -{ 1 }-> splitD#1(@l, @pivot) :|: @l >= 0, z = @pivot, z' = @l, @pivot >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, @pivot), @pivot, @x) :|: @x >= 0, z = 1 + @x + @xs, z' = @pivot, @xs >= 0, @pivot >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' = @pivot, @pivot >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(@x, @pivot)), @ls, @rs, @x) :|: @ls >= 0, z = 1 + @ls + @rs, @x >= 0, z' = @pivot, @pivot >= 0, z'' = @x, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + @ls + (1 + @x + @rs) :|: z = 2, z1 = @x, @ls >= 0, @x >= 0, z' = @ls, @rs >= 0, z'' = @rs
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + @x + @ls) + @rs :|: z1 = @x, @ls >= 0, @x >= 0, z = 1, z' = @ls, @rs >= 0, z'' = @rs
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z = @x, @x >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z = @x, @x >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z = @x, @x >= 0


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

(13) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   split#3(z, z', z'', z1) -{ 1 }-> 1 + @ls + (1 + @x + @rs) :|: z = 2, z1 = @x, @ls >= 0, @x >= 0, z' = @ls, @rs >= 0, z'' = @rs
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + @x + @ls) + @rs :|: z1 = @x, @ls >= 0, @x >= 0, z = 1, z' = @ls, @rs >= 0, z'' = @rs
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + @ls + (1 + @x + @rs) :|: z = 2, z1 = @x, @ls >= 0, @x >= 0, z' = @ls, @rs >= 0, z'' = @rs
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + @x + @ls) + @rs :|: z1 = @x, @ls >= 0, @x >= 0, z = 1, z' = @ls, @rs >= 0, z'' = @rs
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + @x :|: @x >= 0, z = 1 + @x
   #abs(z) -{ 1 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + @x
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #greater(z, z') -{ 1 }-> 2 :|: @y' >= 0, z' = 1 + @y', z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: @x2 >= 0, z = 1 + @x2, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: @x3 >= 0, z' = 1 + @y4, z = 1 + @x3, @y4 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z = 1 + @x5, @x5 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' = 1 + @y'', @y'' >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' = 1 + @y1, @y1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z = 1 + @x', @x' >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: @y3 >= 0, @x1 >= 0, z' = 1 + @y3, z = 1 + @x1, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: @y' >= 0, z' = 1 + @y', z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' = 1 + @y'', @y'' >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' = 1 + @y1, @y1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z = 1 + @x', @x' >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: @y3 >= 0, @x1 >= 0, z' = 1 + @y3, z = 1 + @x1, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: @x2 >= 0, z = 1 + @x2, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: @x3 >= 0, z' = 1 + @y4, z = 1 + @x3, @y4 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z = 1 + @x5, @x5 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z = @x, @x >= 0, z' = @y, @y >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(@x4, @y5)) :|: z' = 1 + @y5, @y5 >= 0, z = 1 + @x4, @x4 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(@x6, @y6)) :|: z = 1 + @x6, z' = 1 + @y6, @x6 >= 0, @y6 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(@y2, @x'')) :|: z = 1 + @x'', z' = 1 + @y2, @y2 >= 0, @x'' >= 0
   append(z, z') -{ 1 }-> append#1(@l, @ys) :|: z = @l, @l >= 0, z' = @ys, @ys >= 0
   append#1(z, z') -{ 1 }-> @ys :|: z' = @ys, z = 0, @ys >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, @ys) :|: z' = @ys, @x >= 0, z = 1 + @x + @xs, @xs >= 0, @ys >= 0
   appendD(z, z') -{ 1 }-> appendD#1(@l, @ys) :|: z = @l, @l >= 0, z' = @ys, @ys >= 0
   appendD#1(z, z') -{ 1 }-> @ys :|: z' = @ys, z = 0, @ys >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, @ys) :|: z' = @ys, @x >= 0, z = 1 + @x + @xs, @xs >= 0, @ys >= 0
   quicksort(z) -{ 1 }-> quicksort#1(@l) :|: z = @l, @l >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + @z + quicksort#1(@ys)) :|: z' = @z, z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, @z >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   quicksortD(z) -{ 1 }-> quicksortD#1(@l) :|: z = @l, @l >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + @z + quicksortD#1(@ys)) :|: z' = @z, z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, @z >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   split(z, z') -{ 1 }-> split#1(@l, @pivot) :|: @l >= 0, z = @pivot, z' = @l, @pivot >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, @pivot), @pivot, @x) :|: @x >= 0, z = 1 + @x + @xs, z' = @pivot, @xs >= 0, @pivot >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' = @pivot, @pivot >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(@x, @pivot)), @ls, @rs, @x) :|: @ls >= 0, z = 1 + @ls + @rs, @x >= 0, z' = @pivot, @pivot >= 0, z'' = @x, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + @ls + (1 + @x + @rs) :|: z = 2, z1 = @x, @ls >= 0, @x >= 0, z' = @ls, @rs >= 0, z'' = @rs
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + @x + @ls) + @rs :|: z1 = @x, @ls >= 0, @x >= 0, z = 1, z' = @ls, @rs >= 0, z'' = @rs
   splitD(z, z') -{ 1 }-> splitD#1(@l, @pivot) :|: @l >= 0, z = @pivot, z' = @l, @pivot >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, @pivot), @pivot, @x) :|: @x >= 0, z = 1 + @x + @xs, z' = @pivot, @xs >= 0, @pivot >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' = @pivot, @pivot >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(@x, @pivot)), @ls, @rs, @x) :|: @ls >= 0, z = 1 + @ls + @rs, @x >= 0, z' = @pivot, @pivot >= 0, z'' = @x, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + @ls + (1 + @x + @rs) :|: z = 2, z1 = @x, @ls >= 0, @x >= 0, z' = @ls, @rs >= 0, z'' = @rs
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + @x + @ls) + @rs :|: z1 = @x, @ls >= 0, @x >= 0, z = 1, z' = @ls, @rs >= 0, z'' = @rs
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z = @x, @x >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z = @x, @x >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z = @x, @x >= 0


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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 1 }-> appendD#1(z, z') :|: z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0


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

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

   { appendD, appendD#1 }
   { split#3 }
   { splitD#3 }
   { #compare }
   { #ckgt }
   { append#1, append }
   { #abs }
   { split#2 }
   { splitD#2 }
   { #greater }
   { testList }
   { split#1 }
   { splitD#1 }
   { split }
   { quicksort#1, quicksort#2 }
   { quicksortD#2, quicksortD#1 }
   { splitD }
   { quicksort }
   { quicksortD }
   { testQuicksort2 }
   { testQuicksort }

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 1 }-> appendD#1(z, z') :|: z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {appendD,appendD#1}, {split#3}, {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 1 }-> appendD#1(z, z') :|: z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {appendD,appendD#1}, {split#3}, {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}

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

(21) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 1 }-> appendD#1(z, z') :|: z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {appendD,appendD#1}, {split#3}, {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: ?, size: O(n^1) [z + z']
  appendD#1: runtime: ?, size: O(n^1) [z + z']

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

(23) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 1 }-> appendD#1(z, z') :|: z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> 1 + @x + appendD(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {split#3}, {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {split#3}, {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: split#3
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2 + z' + z'' + z1

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {split#3}, {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: ?, size: O(n^1) [2 + z' + z'' + z1]

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: splitD#3
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2 + z' + z'' + z1

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {splitD#3}, {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: ?, size: O(n^1) [2 + z' + z'' + z1]

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#compare}, {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: ?, size: O(1) [3]

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(#compare(z'', z')), @ls, @rs, z'') :|: @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(s2) :|: s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(s3) :|: s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(s4), @ls, @rs, z'') :|: s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(s5), @ls, @rs, z'') :|: s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(s2) :|: s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(s3) :|: s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(s4), @ls, @rs, z'') :|: s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(s5), @ls, @rs, z'') :|: s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#ckgt}, {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: ?, size: O(1) [2]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #greater(z, z') -{ 1 }-> #ckgt(s2) :|: s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> #ckgt(s3) :|: s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 2 }-> split#3(#ckgt(s4), @ls, @rs, z'') :|: s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 2 }-> splitD#3(#ckgt(s5), @ls, @rs, z'') :|: s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {append#1,append}, {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: ?, size: O(n^1) [z + z']
  append: runtime: ?, size: O(n^1) [z + z']

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 1 }-> append#1(z, z') :|: z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 1 }-> 1 + @x + append(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + 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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {#abs}, {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: ?, size: O(n^1) [1 + z]

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 1 }-> 1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0))))))))) :|: z >= 0
   testQuicksort(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0
   testQuicksort2(z) -{ 2 }-> quicksort(1 + #abs(0) + (1 + #abs(1 + (1 + (1 + (1 + (1 + 0))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + (1 + #abs(1 + (1 + 0)) + (1 + #abs(1 + (1 + (1 + 0))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + (1 + #abs(1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + (1 + #abs(1 + (1 + (1 + (1 + 0)))) + 0)))))))))) :|: z >= 0

Function symbols to be analyzed: {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split#2}, {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: ?, size: O(n^1) [1 + z + z'']

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

(65) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD#2}, {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: ?, size: O(n^1) [1 + z + z'']

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

(71) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {#greater}, {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: ?, size: O(1) [2]

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

(77) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testList}, {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: ?, size: O(1) [74]

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

(83) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]

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

(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:

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]

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

(87) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split#1}, {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: ?, size: O(n^1) [1 + z]

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

(89) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 2 }-> quicksort#2(split#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 1 }-> split#1(z', z) :|: z' >= 0, z >= 0
   split#1(z, z') -{ 2 }-> split#2(split#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]

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

(93) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD#1}, {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: ?, size: O(n^1) [1 + z]

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

(95) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 2 }-> quicksortD#2(splitD#1(@zs, @z), @z) :|: z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 1 }-> splitD#1(z', z) :|: z' >= 0, z >= 0
   splitD#1(z, z') -{ 2 }-> splitD#2(splitD#1(@xs, z'), z', @x) :|: @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]

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

(99) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {split}, {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: ?, size: O(n^1) [1 + z']

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

(101) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']

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

(105) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksort#1,quicksort#2}, {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: ?, size: O(n^1) [z]
  quicksort#2: runtime: ?, size: O(n^1) [z + z']

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

(107) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: quicksort#1
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 5 + 48*z + 35*z^2

Computed RUNTIME bound using KoAT for: quicksort#2
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 17 + 98*z + 70*z^2

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 1 }-> quicksort#1(z) :|: z >= 0
   quicksort#1(z) -{ 3 + 5*@zs }-> quicksort#2(s44, @z) :|: s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 3 }-> append(quicksort#1(@xs), 1 + z' + quicksort#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']

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

(111) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksortD#2,quicksortD#1}, {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: ?, size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: ?, size: O(n^1) [1 + 3*z]

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

(113) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: quicksortD#2
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 11 + 55*z + 44*z^2

Computed RUNTIME bound using KoAT for: quicksortD#1
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 114 + 148*z + 44*z^2

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 1 }-> quicksortD#1(z) :|: z >= 0
   quicksortD#1(z) -{ 3 + 5*@zs }-> quicksortD#2(s48, @z) :|: s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 3 }-> appendD(quicksortD#1(@xs), 1 + z' + quicksortD#1(@ys)) :|: z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]

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

(117) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {splitD}, {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: ?, size: O(n^1) [1 + z']

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

(119) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']

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

(123) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksort}, {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: ?, size: O(n^1) [z]

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

(125) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: quicksort
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 6 + 48*z + 35*z^2

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 12 }-> quicksort(1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0)))))))))) :|: s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 12 }-> quicksort(1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0)))))))))) :|: s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]

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

(129) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {quicksortD}, {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: ?, size: O(n^1) [1 + 3*z]

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

(131) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: quicksortD
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 115 + 148*z + 44*z^2

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]

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

(135) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testQuicksort2}, {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  testQuicksort2: runtime: ?, size: O(1) [74]

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

(137) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  testQuicksort2: runtime: O(1) [195230], size: O(1) [74]

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  testQuicksort2: runtime: O(1) [195230], size: O(1) [74]

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

(141) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: {testQuicksort}
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  testQuicksort2: runtime: O(1) [195230], size: O(1) [74]
  testQuicksort: runtime: ?, size: O(1) [74]

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

(143) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #abs(z) -{ 1 }-> 0 :|: z = 0
   #abs(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   #abs(z) -{ 1 }-> 1 + (1 + (z - 1)) :|: z - 1 >= 0
   #ckgt(z) -{ 0 }-> 2 :|: z = 2
   #ckgt(z) -{ 0 }-> 1 :|: z = 1
   #ckgt(z) -{ 0 }-> 1 :|: z = 3
   #ckgt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #greater(z, z') -{ 1 }-> s6 :|: s6 >= 0, s6 <= 2, s2 >= 0, s2 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> s7 :|: s7 >= 0, s7 <= 2, s3 >= 0, s3 <= 3, z' - 1 >= 0, z - 1 >= 0
   #greater(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 2 = 2
   #greater(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 2 = 2
   #greater(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 3 = 3
   #greater(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #greater(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 2 = v0
   #greater(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   append(z, z') -{ 4 + 2*z }-> s12 :|: s12 >= 0, s12 <= z + z', z >= 0, z' >= 0
   append#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   append#1(z, z') -{ 5 + 2*@xs }-> 1 + @x + s13 :|: s13 >= 0, s13 <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   appendD(z, z') -{ 2 + 2*z }-> s :|: s >= 0, s <= z + z', z >= 0, z' >= 0
   appendD#1(z, z') -{ 1 }-> z' :|: z = 0, z' >= 0
   appendD#1(z, z') -{ 3 + 2*@xs }-> 1 + @x + s' :|: s' >= 0, s' <= @xs + z', @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   quicksort(z) -{ 6 + 48*z + 35*z^2 }-> s52 :|: s52 >= 0, s52 <= z, z >= 0
   quicksort#1(z) -{ 20 + 5*@zs + 98*s44 + 70*s44^2 }-> s53 :|: s53 >= 0, s53 <= s44 + @z, s44 >= 0, s44 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksort#1(z) -{ 1 }-> 0 :|: z = 0
   quicksort#2(z, z') -{ 17 + 48*@xs + 35*@xs^2 + 48*@ys + 35*@ys^2 + 2*s54 }-> s56 :|: s54 >= 0, s54 <= @xs, s55 >= 0, s55 <= @ys, s56 >= 0, s56 <= s54 + (1 + z' + s55), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksort#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   quicksortD(z) -{ 115 + 148*z + 44*z^2 }-> s57 :|: s57 >= 0, s57 <= 3 * z + 1, z >= 0
   quicksortD#1(z) -{ 14 + 5*@zs + 55*s48 + 44*s48^2 }-> s58 :|: s58 >= 0, s58 <= 3 * @z + 1 + 3 * s48, s48 >= 0, s48 <= @zs + 1, z = 1 + @z + @zs, @zs >= 0, @z >= 0
   quicksortD#1(z) -{ 1 }-> 0 :|: z = 0
   quicksortD#2(z, z') -{ 233 + 148*@xs + 44*@xs^2 + 148*@ys + 44*@ys^2 + 2*s59 }-> s61 :|: s59 >= 0, s59 <= 3 * @xs + 1, s60 >= 0, s60 <= 3 * @ys + 1, s61 >= 0, s61 <= s59 + (1 + z' + s60), z = 1 + @xs + @ys, @xs >= 0, @ys >= 0, z' >= 0
   quicksortD#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   split(z, z') -{ 2 + 5*z' }-> s45 :|: s45 >= 0, s45 <= z' + 1, z' >= 0, z >= 0
   split#1(z, z') -{ 6 + 5*@xs }-> s47 :|: s46 >= 0, s46 <= @xs + 1, s47 >= 0, s47 <= s46 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   split#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   split#2(z, z', z'') -{ 3 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= @ls + @rs + z'' + 2, s4 >= 0, s4 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   split#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   split#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   splitD(z, z') -{ 2 + 5*z' }-> s49 :|: s49 >= 0, s49 <= z' + 1, z' >= 0, z >= 0
   splitD#1(z, z') -{ 6 + 5*@xs }-> s51 :|: s50 >= 0, s50 <= @xs + 1, s51 >= 0, s51 <= s50 + @x + 1, @x >= 0, z = 1 + @x + @xs, @xs >= 0, z' >= 0
   splitD#1(z, z') -{ 1 }-> 1 + 0 + 0 :|: z' >= 0, z = 0
   splitD#2(z, z', z'') -{ 3 }-> s11 :|: s10 >= 0, s10 <= 2, s11 >= 0, s11 <= @ls + @rs + z'' + 2, s5 >= 0, s5 <= 3, @ls >= 0, z = 1 + @ls + @rs, z'' >= 0, z' >= 0, @rs >= 0
   splitD#2(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + z' + (1 + z1 + z'') :|: z = 2, z' >= 0, z1 >= 0, z'' >= 0
   splitD#3(z, z', z'', z1) -{ 1 }-> 1 + (1 + z1 + z') + z'' :|: z' >= 0, z1 >= 0, z = 1, z'' >= 0
   testList(z) -{ 11 }-> 1 + s14 + (1 + s15 + (1 + s16 + (1 + s17 + (1 + s18 + (1 + s19 + (1 + s20 + (1 + s21 + (1 + s22 + (1 + s23 + 0))))))))) :|: s14 >= 0, s14 <= 0 + 1, s15 >= 0, s15 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s16 >= 0, s16 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s17 >= 0, s17 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s18 >= 0, s18 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s19 >= 0, s19 <= 1 + (1 + 0) + 1, s20 >= 0, s20 <= 1 + (1 + (1 + 0)) + 1, s21 >= 0, s21 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s22 >= 0, s22 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s23 >= 0, s23 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort(z) -{ 3998 + 748*s24 + 70*s24*s25 + 70*s24*s26 + 70*s24*s27 + 70*s24*s28 + 70*s24*s29 + 70*s24*s30 + 70*s24*s31 + 70*s24*s32 + 70*s24*s33 + 35*s24^2 + 748*s25 + 70*s25*s26 + 70*s25*s27 + 70*s25*s28 + 70*s25*s29 + 70*s25*s30 + 70*s25*s31 + 70*s25*s32 + 70*s25*s33 + 35*s25^2 + 748*s26 + 70*s26*s27 + 70*s26*s28 + 70*s26*s29 + 70*s26*s30 + 70*s26*s31 + 70*s26*s32 + 70*s26*s33 + 35*s26^2 + 748*s27 + 70*s27*s28 + 70*s27*s29 + 70*s27*s30 + 70*s27*s31 + 70*s27*s32 + 70*s27*s33 + 35*s27^2 + 748*s28 + 70*s28*s29 + 70*s28*s30 + 70*s28*s31 + 70*s28*s32 + 70*s28*s33 + 35*s28^2 + 748*s29 + 70*s29*s30 + 70*s29*s31 + 70*s29*s32 + 70*s29*s33 + 35*s29^2 + 748*s30 + 70*s30*s31 + 70*s30*s32 + 70*s30*s33 + 35*s30^2 + 748*s31 + 70*s31*s32 + 70*s31*s33 + 35*s31^2 + 748*s32 + 70*s32*s33 + 35*s32^2 + 748*s33 + 35*s33^2 }-> s62 :|: s62 >= 0, s62 <= 1 + s24 + (1 + s25 + (1 + s26 + (1 + s27 + (1 + s28 + (1 + s29 + (1 + s30 + (1 + s31 + (1 + s32 + (1 + s33 + 0))))))))), s24 >= 0, s24 <= 0 + 1, s25 >= 0, s25 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s26 >= 0, s26 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s27 >= 0, s27 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s28 >= 0, s28 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s29 >= 0, s29 <= 1 + (1 + 0) + 1, s30 >= 0, s30 <= 1 + (1 + (1 + 0)) + 1, s31 >= 0, s31 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s32 >= 0, s32 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s33 >= 0, s33 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0
   testQuicksort2(z) -{ 3998 + 748*s34 + 70*s34*s35 + 70*s34*s36 + 70*s34*s37 + 70*s34*s38 + 70*s34*s39 + 70*s34*s40 + 70*s34*s41 + 70*s34*s42 + 70*s34*s43 + 35*s34^2 + 748*s35 + 70*s35*s36 + 70*s35*s37 + 70*s35*s38 + 70*s35*s39 + 70*s35*s40 + 70*s35*s41 + 70*s35*s42 + 70*s35*s43 + 35*s35^2 + 748*s36 + 70*s36*s37 + 70*s36*s38 + 70*s36*s39 + 70*s36*s40 + 70*s36*s41 + 70*s36*s42 + 70*s36*s43 + 35*s36^2 + 748*s37 + 70*s37*s38 + 70*s37*s39 + 70*s37*s40 + 70*s37*s41 + 70*s37*s42 + 70*s37*s43 + 35*s37^2 + 748*s38 + 70*s38*s39 + 70*s38*s40 + 70*s38*s41 + 70*s38*s42 + 70*s38*s43 + 35*s38^2 + 748*s39 + 70*s39*s40 + 70*s39*s41 + 70*s39*s42 + 70*s39*s43 + 35*s39^2 + 748*s40 + 70*s40*s41 + 70*s40*s42 + 70*s40*s43 + 35*s40^2 + 748*s41 + 70*s41*s42 + 70*s41*s43 + 35*s41^2 + 748*s42 + 70*s42*s43 + 35*s42^2 + 748*s43 + 35*s43^2 }-> s63 :|: s63 >= 0, s63 <= 1 + s34 + (1 + s35 + (1 + s36 + (1 + s37 + (1 + s38 + (1 + s39 + (1 + s40 + (1 + s41 + (1 + s42 + (1 + s43 + 0))))))))), s34 >= 0, s34 <= 0 + 1, s35 >= 0, s35 <= 1 + (1 + (1 + (1 + (1 + 0)))) + 1, s36 >= 0, s36 <= 1 + (1 + (1 + (1 + (1 + (1 + 0))))) + 1, s37 >= 0, s37 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))))) + 1, s38 >= 0, s38 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0))))))) + 1, s39 >= 0, s39 <= 1 + (1 + 0) + 1, s40 >= 0, s40 <= 1 + (1 + (1 + 0)) + 1, s41 >= 0, s41 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))) + 1, s42 >= 0, s42 <= 1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))) + 1, s43 >= 0, s43 <= 1 + (1 + (1 + (1 + 0))) + 1, z >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  appendD: runtime: O(n^1) [2 + 2*z], size: O(n^1) [z + z']
  appendD#1: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z + z']
  split#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  splitD#3: runtime: O(1) [1], size: O(n^1) [2 + z' + z'' + z1]
  #compare: runtime: O(1) [0], size: O(1) [3]
  #ckgt: runtime: O(1) [0], size: O(1) [2]
  append#1: runtime: O(n^1) [3 + 2*z], size: O(n^1) [z + z']
  append: runtime: O(n^1) [4 + 2*z], size: O(n^1) [z + z']
  #abs: runtime: O(1) [1], size: O(n^1) [1 + z]
  split#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  splitD#2: runtime: O(1) [3], size: O(n^1) [1 + z + z'']
  #greater: runtime: O(1) [1], size: O(1) [2]
  testList: runtime: O(1) [11], size: O(1) [74]
  split#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  splitD#1: runtime: O(n^1) [1 + 5*z], size: O(n^1) [1 + z]
  split: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort#1: runtime: O(n^2) [5 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksort#2: runtime: O(n^2) [17 + 98*z + 70*z^2], size: O(n^1) [z + z']
  quicksortD#2: runtime: O(n^2) [11 + 55*z + 44*z^2], size: O(n^1) [1 + 3*z + 3*z']
  quicksortD#1: runtime: O(n^2) [114 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  splitD: runtime: O(n^1) [2 + 5*z'], size: O(n^1) [1 + z']
  quicksort: runtime: O(n^2) [6 + 48*z + 35*z^2], size: O(n^1) [z]
  quicksortD: runtime: O(n^2) [115 + 148*z + 44*z^2], size: O(n^1) [1 + 3*z]
  testQuicksort2: runtime: O(1) [195230], size: O(1) [74]
  testQuicksort: runtime: O(1) [195230], size: O(1) [74]

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

(145) FinalProof (FINISHED)
Computed overall runtime complexity
----------------------------------------

(146)
BOUNDS(1, n^2)

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

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

(148)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^2, INF).


The TRS R consists of the following rules:

   #abs(#0) -> #0
   #abs(#neg(@x)) -> #pos(@x)
   #abs(#pos(@x)) -> #pos(@x)
   #abs(#s(@x)) -> #pos(#s(@x))
   #greater(@x, @y) -> #ckgt(#compare(@x, @y))
   append(@l, @ys) -> append#1(@l, @ys)
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
   append#1(nil, @ys) -> @ys
   appendD(@l, @ys) -> appendD#1(@l, @ys)
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
   appendD#1(nil, @ys) -> @ys
   quicksort(@l) -> quicksort#1(@l)
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
   quicksort#1(nil) -> nil
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
   quicksortD(@l) -> quicksortD#1(@l)
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
   quicksortD#1(nil) -> nil
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
   split(@pivot, @l) -> split#1(@l, @pivot)
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
   split#1(nil, @pivot) -> tuple#2(nil, nil)
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   splitD(@pivot, @l) -> splitD#1(@l, @pivot)
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
   splitD#1(nil, @pivot) -> tuple#2(nil, nil)
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   testList(@x) -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
   testQuicksort(@x) -> quicksort(testList(#unit))
   testQuicksort2(@x) -> quicksort(testList(#unit))

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

   #ckgt(#EQ) -> #false
   #ckgt(#GT) -> #true
   #ckgt(#LT) -> #false
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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

(149) SlicingProof (LOWER BOUND(ID))
Sliced the following arguments:
testList/0
testQuicksort/0
testQuicksort2/0

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

(150)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^2, INF).


The TRS R consists of the following rules:

   #abs(#0) -> #0
   #abs(#neg(@x)) -> #pos(@x)
   #abs(#pos(@x)) -> #pos(@x)
   #abs(#s(@x)) -> #pos(#s(@x))
   #greater(@x, @y) -> #ckgt(#compare(@x, @y))
   append(@l, @ys) -> append#1(@l, @ys)
   append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
   append#1(nil, @ys) -> @ys
   appendD(@l, @ys) -> appendD#1(@l, @ys)
   appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
   appendD#1(nil, @ys) -> @ys
   quicksort(@l) -> quicksort#1(@l)
   quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
   quicksort#1(nil) -> nil
   quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
   quicksortD(@l) -> quicksortD#1(@l)
   quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
   quicksortD#1(nil) -> nil
   quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
   split(@pivot, @l) -> split#1(@l, @pivot)
   split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
   split#1(nil, @pivot) -> tuple#2(nil, nil)
   split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
   split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   splitD(@pivot, @l) -> splitD#1(@l, @pivot)
   splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
   splitD#1(nil, @pivot) -> tuple#2(nil, nil)
   splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
   splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
   splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
   testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
   testQuicksort -> quicksort(testList)
   testQuicksort2 -> quicksort(testList)

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

   #ckgt(#EQ) -> #false
   #ckgt(#GT) -> #true
   #ckgt(#LT) -> #false
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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

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

(152)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil

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

(153) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
#compare, append, append#1, appendD, appendD#1, quicksort, quicksort#1, split, quicksortD, quicksortD#1, splitD, split#1, splitD#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
split < quicksort#1
split = split#1
quicksortD = quicksortD#1
splitD < quicksortD#1
splitD = splitD#1

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

(154)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
#compare, append, append#1, appendD, appendD#1, quicksort, quicksort#1, split, quicksortD, quicksortD#1, splitD, split#1, splitD#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
split < quicksort#1
split = split#1
quicksortD = quicksortD#1
splitD < quicksortD#1
splitD = splitD#1

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

(155) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)

Induction Base:
#compare(gen_#0:#neg:#pos:#s6_4(0), gen_#0:#neg:#pos:#s6_4(0)) ->_R^Omega(0)
#EQ

Induction Step:
#compare(gen_#0:#neg:#pos:#s6_4(+(n9_4, 1)), gen_#0:#neg:#pos:#s6_4(+(n9_4, 1))) ->_R^Omega(0)
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) ->_IH
#EQ

We have rt in Omega(1) and sz in O(n). Thus, we have irc_R in Omega(n^0).
----------------------------------------

(156)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
splitD#1, append, append#1, appendD, appendD#1, quicksort, quicksort#1, split, quicksortD, quicksortD#1, splitD, split#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
split < quicksort#1
split = split#1
quicksortD = quicksortD#1
splitD < quicksortD#1
splitD = splitD#1

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

(157) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)

Induction Base:
splitD#1(gen_:::nil7_4(0), gen_#0:#neg:#pos:#s6_4(0)) ->_R^Omega(1)
tuple#2(nil, nil)

Induction Step:
splitD#1(gen_:::nil7_4(+(n318812_4, 1)), gen_#0:#neg:#pos:#s6_4(0)) ->_R^Omega(1)
splitD#2(splitD(gen_#0:#neg:#pos:#s6_4(0), gen_:::nil7_4(n318812_4)), gen_#0:#neg:#pos:#s6_4(0), #0) ->_R^Omega(1)
splitD#2(splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)), gen_#0:#neg:#pos:#s6_4(0), #0) ->_IH
splitD#2(tuple#2(gen_:::nil7_4(c318813_4), gen_:::nil7_4(0)), gen_#0:#neg:#pos:#s6_4(0), #0) ->_R^Omega(1)
splitD#3(#greater(#0, gen_#0:#neg:#pos:#s6_4(0)), gen_:::nil7_4(n318812_4), gen_:::nil7_4(0), #0) ->_R^Omega(1)
splitD#3(#ckgt(#compare(#0, gen_#0:#neg:#pos:#s6_4(0))), gen_:::nil7_4(n318812_4), gen_:::nil7_4(0), #0) ->_L^Omega(0)
splitD#3(#ckgt(#EQ), gen_:::nil7_4(n318812_4), gen_:::nil7_4(0), #0) ->_R^Omega(0)
splitD#3(#false, gen_:::nil7_4(n318812_4), gen_:::nil7_4(0), #0) ->_R^Omega(1)
tuple#2(::(#0, gen_:::nil7_4(n318812_4)), gen_:::nil7_4(0))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(158)
Complex Obligation (BEST)

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

(159)
Obligation:
Proved the lower bound n^1 for the following obligation:

Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
splitD#1, append, append#1, appendD, appendD#1, quicksort, quicksort#1, split, quicksortD, quicksortD#1, splitD, split#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
split < quicksort#1
split = split#1
quicksortD = quicksortD#1
splitD < quicksortD#1
splitD = splitD#1

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

(160) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(161)
BOUNDS(n^1, INF)

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

(162)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
splitD, append, append#1, appendD, appendD#1, quicksort, quicksort#1, split, quicksortD, quicksortD#1, split#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
split < quicksort#1
split = split#1
quicksortD = quicksortD#1
splitD < quicksortD#1
splitD = splitD#1

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

(163) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)

Induction Base:
split#1(gen_:::nil7_4(0), gen_#0:#neg:#pos:#s6_4(0)) ->_R^Omega(1)
tuple#2(nil, nil)

Induction Step:
split#1(gen_:::nil7_4(+(n320997_4, 1)), gen_#0:#neg:#pos:#s6_4(0)) ->_R^Omega(1)
split#2(split(gen_#0:#neg:#pos:#s6_4(0), gen_:::nil7_4(n320997_4)), gen_#0:#neg:#pos:#s6_4(0), #0) ->_R^Omega(1)
split#2(split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)), gen_#0:#neg:#pos:#s6_4(0), #0) ->_IH
split#2(tuple#2(gen_:::nil7_4(c320998_4), gen_:::nil7_4(0)), gen_#0:#neg:#pos:#s6_4(0), #0) ->_R^Omega(1)
split#3(#greater(#0, gen_#0:#neg:#pos:#s6_4(0)), gen_:::nil7_4(n320997_4), gen_:::nil7_4(0), #0) ->_R^Omega(1)
split#3(#ckgt(#compare(#0, gen_#0:#neg:#pos:#s6_4(0))), gen_:::nil7_4(n320997_4), gen_:::nil7_4(0), #0) ->_L^Omega(0)
split#3(#ckgt(#EQ), gen_:::nil7_4(n320997_4), gen_:::nil7_4(0), #0) ->_R^Omega(0)
split#3(#false, gen_:::nil7_4(n320997_4), gen_:::nil7_4(0), #0) ->_R^Omega(1)
tuple#2(::(#0, gen_:::nil7_4(n320997_4)), gen_:::nil7_4(0))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(164)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
split, append, append#1, appendD, appendD#1, quicksort, quicksort#1, quicksortD, quicksortD#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
split < quicksort#1
split = split#1
quicksortD = quicksortD#1

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

(165) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n323205_4, b)), rt in Omega(1 + n323205_4)

Induction Base:
appendD#1(gen_:::nil7_4(0), gen_:::nil7_4(b)) ->_R^Omega(1)
gen_:::nil7_4(b)

Induction Step:
appendD#1(gen_:::nil7_4(+(n323205_4, 1)), gen_:::nil7_4(b)) ->_R^Omega(1)
::(#0, appendD(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b))) ->_R^Omega(1)
::(#0, appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b))) ->_IH
::(#0, gen_:::nil7_4(+(b, c323206_4)))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(166)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)
appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n323205_4, b)), rt in Omega(1 + n323205_4)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
appendD, append, append#1, quicksort, quicksort#1, quicksortD, quicksortD#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
appendD = appendD#1
appendD < quicksortD#1
quicksort = quicksort#1
quicksortD = quicksortD#1

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

(167) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
quicksortD#1(gen_:::nil7_4(n324930_4)) -> gen_:::nil7_4(n324930_4), rt in Omega(1 + n324930_4 + n324930_4^2)

Induction Base:
quicksortD#1(gen_:::nil7_4(0)) ->_R^Omega(1)
nil

Induction Step:
quicksortD#1(gen_:::nil7_4(+(n324930_4, 1))) ->_R^Omega(1)
quicksortD#2(splitD(#0, gen_:::nil7_4(n324930_4)), #0) ->_R^Omega(1)
quicksortD#2(splitD#1(gen_:::nil7_4(n324930_4), #0), #0) ->_L^Omega(1 + n324930_4)
quicksortD#2(tuple#2(gen_:::nil7_4(n324930_4), gen_:::nil7_4(0)), #0) ->_R^Omega(1)
appendD(quicksortD(gen_:::nil7_4(n324930_4)), ::(#0, quicksortD(gen_:::nil7_4(0)))) ->_R^Omega(1)
appendD(quicksortD#1(gen_:::nil7_4(n324930_4)), ::(#0, quicksortD(gen_:::nil7_4(0)))) ->_IH
appendD(gen_:::nil7_4(c324931_4), ::(#0, quicksortD(gen_:::nil7_4(0)))) ->_R^Omega(1)
appendD(gen_:::nil7_4(n324930_4), ::(#0, quicksortD#1(gen_:::nil7_4(0)))) ->_R^Omega(1)
appendD(gen_:::nil7_4(n324930_4), ::(#0, nil)) ->_R^Omega(1)
appendD#1(gen_:::nil7_4(n324930_4), ::(#0, nil)) ->_L^Omega(1 + n324930_4)
gen_:::nil7_4(+(n324930_4, +(0, 1)))

We have rt in Omega(n^2) and sz in O(n). Thus, we have irc_R in Omega(n^2).
----------------------------------------

(168)
Complex Obligation (BEST)

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

(169)
Obligation:
Proved the lower bound n^2 for the following obligation:

Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)
appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n323205_4, b)), rt in Omega(1 + n323205_4)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
quicksortD#1, append, append#1, quicksort, quicksort#1, quicksortD

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
quicksort = quicksort#1
quicksortD = quicksortD#1

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

(170) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(171)
BOUNDS(n^2, INF)

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

(172)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)
appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n323205_4, b)), rt in Omega(1 + n323205_4)
quicksortD#1(gen_:::nil7_4(n324930_4)) -> gen_:::nil7_4(n324930_4), rt in Omega(1 + n324930_4 + n324930_4^2)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
quicksortD, append, append#1, quicksort, quicksort#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
quicksort = quicksort#1
quicksortD = quicksortD#1

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

(173) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
append#1(gen_:::nil7_4(n326285_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n326285_4, b)), rt in Omega(1 + n326285_4)

Induction Base:
append#1(gen_:::nil7_4(0), gen_:::nil7_4(b)) ->_R^Omega(1)
gen_:::nil7_4(b)

Induction Step:
append#1(gen_:::nil7_4(+(n326285_4, 1)), gen_:::nil7_4(b)) ->_R^Omega(1)
::(#0, append(gen_:::nil7_4(n326285_4), gen_:::nil7_4(b))) ->_R^Omega(1)
::(#0, append#1(gen_:::nil7_4(n326285_4), gen_:::nil7_4(b))) ->_IH
::(#0, gen_:::nil7_4(+(b, c326286_4)))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(174)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)
appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n323205_4, b)), rt in Omega(1 + n323205_4)
quicksortD#1(gen_:::nil7_4(n324930_4)) -> gen_:::nil7_4(n324930_4), rt in Omega(1 + n324930_4 + n324930_4^2)
append#1(gen_:::nil7_4(n326285_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n326285_4, b)), rt in Omega(1 + n326285_4)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
append, quicksort, quicksort#1

They will be analysed ascendingly in the following order:
append = append#1
append < quicksort#1
quicksort = quicksort#1

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

(175) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
quicksort#1(gen_:::nil7_4(n328054_4)) -> gen_:::nil7_4(n328054_4), rt in Omega(1 + n328054_4 + n328054_4^2)

Induction Base:
quicksort#1(gen_:::nil7_4(0)) ->_R^Omega(1)
nil

Induction Step:
quicksort#1(gen_:::nil7_4(+(n328054_4, 1))) ->_R^Omega(1)
quicksort#2(split(#0, gen_:::nil7_4(n328054_4)), #0) ->_R^Omega(1)
quicksort#2(split#1(gen_:::nil7_4(n328054_4), #0), #0) ->_L^Omega(1 + n328054_4)
quicksort#2(tuple#2(gen_:::nil7_4(n328054_4), gen_:::nil7_4(0)), #0) ->_R^Omega(1)
append(quicksort(gen_:::nil7_4(n328054_4)), ::(#0, quicksort(gen_:::nil7_4(0)))) ->_R^Omega(1)
append(quicksort#1(gen_:::nil7_4(n328054_4)), ::(#0, quicksort(gen_:::nil7_4(0)))) ->_IH
append(gen_:::nil7_4(c328055_4), ::(#0, quicksort(gen_:::nil7_4(0)))) ->_R^Omega(1)
append(gen_:::nil7_4(n328054_4), ::(#0, quicksort#1(gen_:::nil7_4(0)))) ->_R^Omega(1)
append(gen_:::nil7_4(n328054_4), ::(#0, nil)) ->_R^Omega(1)
append#1(gen_:::nil7_4(n328054_4), ::(#0, nil)) ->_L^Omega(1 + n328054_4)
gen_:::nil7_4(+(n328054_4, +(0, 1)))

We have rt in Omega(n^2) and sz in O(n). Thus, we have irc_R in Omega(n^2).
----------------------------------------

(176)
Obligation:
Innermost TRS:
Rules:
#abs(#0) -> #0
#abs(#neg(@x)) -> #pos(@x)
#abs(#pos(@x)) -> #pos(@x)
#abs(#s(@x)) -> #pos(#s(@x))
#greater(@x, @y) -> #ckgt(#compare(@x, @y))
append(@l, @ys) -> append#1(@l, @ys)
append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
append#1(nil, @ys) -> @ys
appendD(@l, @ys) -> appendD#1(@l, @ys)
appendD#1(::(@x, @xs), @ys) -> ::(@x, appendD(@xs, @ys))
appendD#1(nil, @ys) -> @ys
quicksort(@l) -> quicksort#1(@l)
quicksort#1(::(@z, @zs)) -> quicksort#2(split(@z, @zs), @z)
quicksort#1(nil) -> nil
quicksort#2(tuple#2(@xs, @ys), @z) -> append(quicksort(@xs), ::(@z, quicksort(@ys)))
quicksortD(@l) -> quicksortD#1(@l)
quicksortD#1(::(@z, @zs)) -> quicksortD#2(splitD(@z, @zs), @z)
quicksortD#1(nil) -> nil
quicksortD#2(tuple#2(@xs, @ys), @z) -> appendD(quicksortD(@xs), ::(@z, quicksortD(@ys)))
split(@pivot, @l) -> split#1(@l, @pivot)
split#1(::(@x, @xs), @pivot) -> split#2(split(@pivot, @xs), @pivot, @x)
split#1(nil, @pivot) -> tuple#2(nil, nil)
split#2(tuple#2(@ls, @rs), @pivot, @x) -> split#3(#greater(@x, @pivot), @ls, @rs, @x)
split#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
split#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
splitD(@pivot, @l) -> splitD#1(@l, @pivot)
splitD#1(::(@x, @xs), @pivot) -> splitD#2(splitD(@pivot, @xs), @pivot, @x)
splitD#1(nil, @pivot) -> tuple#2(nil, nil)
splitD#2(tuple#2(@ls, @rs), @pivot, @x) -> splitD#3(#greater(@x, @pivot), @ls, @rs, @x)
splitD#3(#false, @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
splitD#3(#true, @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
testList -> ::(#abs(#0), ::(#abs(#pos(#s(#s(#s(#s(#0)))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#0))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0))))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0))))))))), ::(#abs(#pos(#s(#0))), ::(#abs(#pos(#s(#s(#0)))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0)))))))))), ::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0)))))))), ::(#abs(#pos(#s(#s(#s(#0))))), nil))))))))))
testQuicksort -> quicksort(testList)
testQuicksort2 -> quicksort(testList)
#ckgt(#EQ) -> #false
#ckgt(#GT) -> #true
#ckgt(#LT) -> #false
#compare(#0, #0) -> #EQ
#compare(#0, #neg(@y)) -> #GT
#compare(#0, #pos(@y)) -> #LT
#compare(#0, #s(@y)) -> #LT
#compare(#neg(@x), #0) -> #LT
#compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
#compare(#neg(@x), #pos(@y)) -> #LT
#compare(#pos(@x), #0) -> #GT
#compare(#pos(@x), #neg(@y)) -> #GT
#compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
#compare(#s(@x), #0) -> #GT
#compare(#s(@x), #s(@y)) -> #compare(@x, @y)

Types:
#abs :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#greater :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#ckgt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
append :: :::nil -> :::nil -> :::nil
append#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
appendD :: :::nil -> :::nil -> :::nil
appendD#1 :: :::nil -> :::nil -> :::nil
quicksort :: :::nil -> :::nil
quicksort#1 :: :::nil -> :::nil
quicksort#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
split :: #0:#neg:#pos:#s -> :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
quicksortD :: :::nil -> :::nil
quicksortD#1 :: :::nil -> :::nil
quicksortD#2 :: tuple#2 -> #0:#neg:#pos:#s -> :::nil
splitD :: #0:#neg:#pos:#s -> :::nil -> tuple#2
split#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
split#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
split#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
#false :: #false:#true
#true :: #false:#true
splitD#1 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
splitD#2 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
splitD#3 :: #false:#true -> :::nil -> :::nil -> #0:#neg:#pos:#s -> tuple#2
testList :: :::nil
testQuicksort :: :::nil
testQuicksort2 :: :::nil
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
hole_#0:#neg:#pos:#s1_4 :: #0:#neg:#pos:#s
hole_#false:#true2_4 :: #false:#true
hole_#EQ:#GT:#LT3_4 :: #EQ:#GT:#LT
hole_:::nil4_4 :: :::nil
hole_tuple#25_4 :: tuple#2
gen_#0:#neg:#pos:#s6_4 :: Nat -> #0:#neg:#pos:#s
gen_:::nil7_4 :: Nat -> :::nil


Lemmas:
#compare(gen_#0:#neg:#pos:#s6_4(n9_4), gen_#0:#neg:#pos:#s6_4(n9_4)) -> #EQ, rt in Omega(0)
splitD#1(gen_:::nil7_4(n318812_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n318812_4), gen_:::nil7_4(0)), rt in Omega(1 + n318812_4)
split#1(gen_:::nil7_4(n320997_4), gen_#0:#neg:#pos:#s6_4(0)) -> tuple#2(gen_:::nil7_4(n320997_4), gen_:::nil7_4(0)), rt in Omega(1 + n320997_4)
appendD#1(gen_:::nil7_4(n323205_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n323205_4, b)), rt in Omega(1 + n323205_4)
quicksortD#1(gen_:::nil7_4(n324930_4)) -> gen_:::nil7_4(n324930_4), rt in Omega(1 + n324930_4 + n324930_4^2)
append#1(gen_:::nil7_4(n326285_4), gen_:::nil7_4(b)) -> gen_:::nil7_4(+(n326285_4, b)), rt in Omega(1 + n326285_4)
quicksort#1(gen_:::nil7_4(n328054_4)) -> gen_:::nil7_4(n328054_4), rt in Omega(1 + n328054_4 + n328054_4^2)


Generator Equations:
gen_#0:#neg:#pos:#s6_4(0) <=> #0
gen_#0:#neg:#pos:#s6_4(+(x, 1)) <=> #neg(gen_#0:#neg:#pos:#s6_4(x))
gen_:::nil7_4(0) <=> nil
gen_:::nil7_4(+(x, 1)) <=> ::(#0, gen_:::nil7_4(x))


The following defined symbols remain to be analysed:
quicksort

They will be analysed ascendingly in the following order:
quicksort = quicksort#1