WORST_CASE(?,O(n^2))
proof of input_QG5n0QA94u.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


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

(0) CpxRelTRS
(1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 135 ms]
(2) CpxRelTRS
(3) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(4) CdtProblem
(5) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CdtProblem
(7) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
(8) CdtProblem
(9) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
(10) CdtProblem
(11) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(12) CpxRelTRS
(13) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(14) CpxWeightedTrs
(15) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
(16) CpxTypedWeightedTrs
(17) CompletionProof [UPPER BOUND(ID), 0 ms]
(18) CpxTypedWeightedCompleteTrs
(19) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
(20) CpxTypedWeightedCompleteTrs
(21) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
(22) CpxRNTS
(23) InliningProof [UPPER BOUND(ID), 1087 ms]
(24) CpxRNTS
(25) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
(26) CpxRNTS
(27) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
(28) CpxRNTS
(29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(30) CpxRNTS
(31) IntTrsBoundProof [UPPER BOUND(ID), 957 ms]
(32) CpxRNTS
(33) IntTrsBoundProof [UPPER BOUND(ID), 196 ms]
(34) CpxRNTS
(35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(36) CpxRNTS
(37) IntTrsBoundProof [UPPER BOUND(ID), 340 ms]
(38) CpxRNTS
(39) IntTrsBoundProof [UPPER BOUND(ID), 73 ms]
(40) CpxRNTS
(41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(42) CpxRNTS
(43) IntTrsBoundProof [UPPER BOUND(ID), 360 ms]
(44) CpxRNTS
(45) IntTrsBoundProof [UPPER BOUND(ID), 104 ms]
(46) CpxRNTS
(47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(48) CpxRNTS
(49) IntTrsBoundProof [UPPER BOUND(ID), 167 ms]
(50) CpxRNTS
(51) IntTrsBoundProof [UPPER BOUND(ID), 33 ms]
(52) CpxRNTS
(53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(54) CpxRNTS
(55) IntTrsBoundProof [UPPER BOUND(ID), 500 ms]
(56) CpxRNTS
(57) IntTrsBoundProof [UPPER BOUND(ID), 89 ms]
(58) CpxRNTS
(59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(60) CpxRNTS
(61) IntTrsBoundProof [UPPER BOUND(ID), 280 ms]
(62) CpxRNTS
(63) IntTrsBoundProof [UPPER BOUND(ID), 43 ms]
(64) CpxRNTS
(65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(66) CpxRNTS
(67) IntTrsBoundProof [UPPER BOUND(ID), 218 ms]
(68) CpxRNTS
(69) IntTrsBoundProof [UPPER BOUND(ID), 2 ms]
(70) CpxRNTS
(71) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(72) CpxRNTS
(73) IntTrsBoundProof [UPPER BOUND(ID), 339 ms]
(74) CpxRNTS
(75) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
(76) CpxRNTS
(77) ResultPropagationProof [UPPER BOUND(ID), 1 ms]
(78) CpxRNTS
(79) IntTrsBoundProof [UPPER BOUND(ID), 168 ms]
(80) CpxRNTS
(81) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
(82) CpxRNTS
(83) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(84) CpxRNTS
(85) IntTrsBoundProof [UPPER BOUND(ID), 369 ms]
(86) CpxRNTS
(87) IntTrsBoundProof [UPPER BOUND(ID), 191 ms]
(88) CpxRNTS
(89) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(90) CpxRNTS
(91) IntTrsBoundProof [UPPER BOUND(ID), 136 ms]
(92) CpxRNTS
(93) IntTrsBoundProof [UPPER BOUND(ID), 32 ms]
(94) CpxRNTS
(95) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(96) CpxRNTS
(97) IntTrsBoundProof [UPPER BOUND(ID), 368 ms]
(98) CpxRNTS
(99) IntTrsBoundProof [UPPER BOUND(ID), 114 ms]
(100) CpxRNTS
(101) FinalProof [FINISHED, 0 ms]
(102) BOUNDS(1, n^2)


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

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


The TRS R consists of the following rules:

   #less(@x, @y) -> #cklt(#compare(@x, @y))
   findMin(@l) -> findMin#1(@l)
   findMin#1(::(@x, @xs)) -> findMin#2(findMin(@xs), @x)
   findMin#1(nil) -> nil
   findMin#2(::(@y, @ys), @x) -> findMin#3(#less(@x, @y), @x, @y, @ys)
   findMin#2(nil, @x) -> ::(@x, nil)
   findMin#3(#false, @x, @y, @ys) -> ::(@y, ::(@x, @ys))
   findMin#3(#true, @x, @y, @ys) -> ::(@x, ::(@y, @ys))
   minSort(@l) -> minSort#1(findMin(@l))
   minSort#1(::(@x, @xs)) -> ::(@x, minSort(@xs))
   minSort#1(nil) -> nil

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

   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #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: PARALLEL_INNERMOST
----------------------------------------

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

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


The TRS R consists of the following rules:

   #less(@x, @y) -> #cklt(#compare(@x, @y))
   findMin(@l) -> findMin#1(@l)
   findMin#1(::(@x, @xs)) -> findMin#2(findMin(@xs), @x)
   findMin#1(nil) -> nil
   findMin#2(::(@y, @ys), @x) -> findMin#3(#less(@x, @y), @x, @y, @ys)
   findMin#2(nil, @x) -> ::(@x, nil)
   findMin#3(#false, @x, @y, @ys) -> ::(@y, ::(@x, @ys))
   findMin#3(#true, @x, @y, @ys) -> ::(@x, ::(@y, @ys))
   minSort(@l) -> minSort#1(findMin(@l))
   minSort#1(::(@x, @xs)) -> ::(@x, minSort(@xs))
   minSort#1(nil) -> nil

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

   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #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: PARALLEL_INNERMOST
----------------------------------------

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

(4)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   findMin(z0) -> findMin#1(z0)
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0)
   findMin#1(nil) -> nil
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1)
   findMin#2(nil, z0) -> ::(z0, nil)
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2))
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2))
   minSort(z0) -> minSort#1(findMin(z0))
   minSort#1(::(z0, z1)) -> ::(z0, minSort(z1))
   minSort#1(nil) -> nil
Tuples:
   #CKLT(#EQ) -> c
   #CKLT(#GT) -> c1
   #CKLT(#LT) -> c2
   #COMPARE(#0, #0) -> c3
   #COMPARE(#0, #neg(z0)) -> c4
   #COMPARE(#0, #pos(z0)) -> c5
   #COMPARE(#0, #s(z0)) -> c6
   #COMPARE(#neg(z0), #0) -> c7
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#neg(z0), #pos(z1)) -> c9
   #COMPARE(#pos(z0), #0) -> c10
   #COMPARE(#pos(z0), #neg(z1)) -> c11
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #0) -> c13
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   FINDMIN#1(nil) -> c18
   FINDMIN#2(::(z0, z1), z2) -> c19(FINDMIN#3(#less(z2, z0), z2, z0, z1), #LESS(z2, z0))
   FINDMIN#2(nil, z0) -> c20
   FINDMIN#3(#false, z0, z1, z2) -> c21
   FINDMIN#3(#true, z0, z1, z2) -> c22
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   MINSORT#1(nil) -> c25
S tuples:
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   FINDMIN#1(nil) -> c18
   FINDMIN#2(::(z0, z1), z2) -> c19(FINDMIN#3(#less(z2, z0), z2, z0, z1), #LESS(z2, z0))
   FINDMIN#2(nil, z0) -> c20
   FINDMIN#3(#false, z0, z1, z2) -> c21
   FINDMIN#3(#true, z0, z1, z2) -> c22
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   MINSORT#1(nil) -> c25
K tuples:none
Defined Rule Symbols:   #less_2, findMin_1, findMin#1_1, findMin#2_2, findMin#3_4, minSort_1, minSort#1_1, #cklt_1, #compare_2

Defined Pair Symbols:   #CKLT_1, #COMPARE_2, #LESS_2, FINDMIN_1, FINDMIN#1_1, FINDMIN#2_2, FINDMIN#3_4, MINSORT_1, MINSORT#1_1

Compound Symbols:   c, c1, c2, c3, c4, c5, c6, c7, c8_1, c9, c10, c11, c12_1, c13, c14_1, c15_2, c16_1, c17_2, c18, c19_2, c20, c21, c22, c23_2, c24_1, c25


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

(5) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 17 trailing nodes:
   FINDMIN#3(#true, z0, z1, z2) -> c22
   FINDMIN#2(nil, z0) -> c20
   #CKLT(#LT) -> c2
   MINSORT#1(nil) -> c25
   #COMPARE(#neg(z0), #0) -> c7
   #COMPARE(#0, #0) -> c3
   #COMPARE(#0, #pos(z0)) -> c5
   #COMPARE(#s(z0), #0) -> c13
   #COMPARE(#0, #neg(z0)) -> c4
   FINDMIN#3(#false, z0, z1, z2) -> c21
   #CKLT(#EQ) -> c
   FINDMIN#1(nil) -> c18
   #COMPARE(#neg(z0), #pos(z1)) -> c9
   #CKLT(#GT) -> c1
   #COMPARE(#0, #s(z0)) -> c6
   #COMPARE(#pos(z0), #neg(z1)) -> c11
   #COMPARE(#pos(z0), #0) -> c10

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

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   findMin(z0) -> findMin#1(z0)
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0)
   findMin#1(nil) -> nil
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1)
   findMin#2(nil, z0) -> ::(z0, nil)
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2))
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2))
   minSort(z0) -> minSort#1(findMin(z0))
   minSort#1(::(z0, z1)) -> ::(z0, minSort(z1))
   minSort#1(nil) -> nil
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(FINDMIN#3(#less(z2, z0), z2, z0, z1), #LESS(z2, z0))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
S tuples:
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(FINDMIN#3(#less(z2, z0), z2, z0, z1), #LESS(z2, z0))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
K tuples:none
Defined Rule Symbols:   #less_2, findMin_1, findMin#1_1, findMin#2_2, findMin#3_4, minSort_1, minSort#1_1, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, #LESS_2, FINDMIN_1, FINDMIN#1_1, FINDMIN#2_2, MINSORT_1, MINSORT#1_1

Compound Symbols:   c8_1, c12_1, c14_1, c15_2, c16_1, c17_2, c19_2, c23_2, c24_1


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

(7) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(8)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   findMin(z0) -> findMin#1(z0)
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0)
   findMin#1(nil) -> nil
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1)
   findMin#2(nil, z0) -> ::(z0, nil)
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2))
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2))
   minSort(z0) -> minSort#1(findMin(z0))
   minSort#1(::(z0, z1)) -> ::(z0, minSort(z1))
   minSort#1(nil) -> nil
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0))
S tuples:
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0))
K tuples:none
Defined Rule Symbols:   #less_2, findMin_1, findMin#1_1, findMin#2_2, findMin#3_4, minSort_1, minSort#1_1, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, FINDMIN_1, FINDMIN#1_1, MINSORT_1, MINSORT#1_1, #LESS_2, FINDMIN#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_2, c23_2, c24_1, c15_1, c19_1


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

(9) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   minSort(z0) -> minSort#1(findMin(z0))
   minSort#1(::(z0, z1)) -> ::(z0, minSort(z1))
   minSort#1(nil) -> nil

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

(10)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   findMin(z0) -> findMin#1(z0)
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0)
   findMin#1(nil) -> nil
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1)
   findMin#2(nil, z0) -> ::(z0, nil)
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2))
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2))
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0))
S tuples:
   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0))
K tuples:none
Defined Rule Symbols:   findMin_1, findMin#1_1, findMin#2_2, findMin#3_4, #less_2, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, FINDMIN_1, FINDMIN#1_1, MINSORT_1, MINSORT#1_1, #LESS_2, FINDMIN#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_2, c23_2, c24_1, c15_1, c19_1


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

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

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


The TRS R consists of the following rules:

   FINDMIN(z0) -> c16(FINDMIN#1(z0))
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1))
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0))
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0))

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

   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   findMin(z0) -> findMin#1(z0)
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0)
   findMin#1(nil) -> nil
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1)
   findMin#2(nil, z0) -> ::(z0, nil)
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2))
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2))
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)

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

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

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

   FINDMIN(z0) -> c16(FINDMIN#1(z0)) [1]
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1)) [1]
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0)) [1]
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1)) [1]
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) [1]
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0)) [1]
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) [0]
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) [0]
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) [0]
   findMin(z0) -> findMin#1(z0) [0]
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0) [0]
   findMin#1(nil) -> nil [0]
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1) [0]
   findMin#2(nil, z0) -> ::(z0, nil) [0]
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2)) [0]
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2)) [0]
   #less(z0, z1) -> #cklt(#compare(z0, z1)) [0]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(z0)) -> #GT [0]
   #compare(#0, #pos(z0)) -> #LT [0]
   #compare(#0, #s(z0)) -> #LT [0]
   #compare(#neg(z0), #0) -> #LT [0]
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) [0]
   #compare(#neg(z0), #pos(z1)) -> #LT [0]
   #compare(#pos(z0), #0) -> #GT [0]
   #compare(#pos(z0), #neg(z1)) -> #GT [0]
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) [0]
   #compare(#s(z0), #0) -> #GT [0]
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1) [0]

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

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

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

   FINDMIN(z0) -> c16(FINDMIN#1(z0)) [1]
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1)) [1]
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0)) [1]
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1)) [1]
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) [1]
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0)) [1]
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) [0]
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) [0]
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) [0]
   findMin(z0) -> findMin#1(z0) [0]
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0) [0]
   findMin#1(nil) -> nil [0]
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1) [0]
   findMin#2(nil, z0) -> ::(z0, nil) [0]
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2)) [0]
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2)) [0]
   #less(z0, z1) -> #cklt(#compare(z0, z1)) [0]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(z0)) -> #GT [0]
   #compare(#0, #pos(z0)) -> #LT [0]
   #compare(#0, #s(z0)) -> #LT [0]
   #compare(#neg(z0), #0) -> #LT [0]
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) [0]
   #compare(#neg(z0), #pos(z1)) -> #LT [0]
   #compare(#pos(z0), #0) -> #GT [0]
   #compare(#pos(z0), #neg(z1)) -> #GT [0]
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) [0]
   #compare(#s(z0), #0) -> #GT [0]
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1) [0]

The TRS has the following type information:
FINDMIN :: :::nil -> c16
c16 :: c17 -> c16
FINDMIN#1 :: :::nil -> c17
:: :: #neg:#pos:#s:#0 -> :::nil -> :::nil
c17 :: c19 -> c16 -> c17
FINDMIN#2 :: :::nil -> #neg:#pos:#s:#0 -> c19
findMin :: :::nil -> :::nil
MINSORT :: :::nil -> c23
c23 :: c24 -> c16 -> c23
MINSORT#1 :: :::nil -> c24
c24 :: c23 -> c24
#LESS :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> c15
c15 :: c8:c12:c14 -> c15
#COMPARE :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> c8:c12:c14
c19 :: c15 -> c19
#neg :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c8 :: c8:c12:c14 -> c8:c12:c14
#pos :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c12 :: c8:c12:c14 -> c8:c12:c14
#s :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c14 :: c8:c12:c14 -> c8:c12:c14
findMin#1 :: :::nil -> :::nil
findMin#2 :: :::nil -> #neg:#pos:#s:#0 -> :::nil
nil :: :::nil
findMin#3 :: #false:#true -> #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> :::nil -> :::nil
#less :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> #false:#true
#false :: #false:#true
#true :: #false:#true
#cklt :: #EQ:#GT:#LT -> #false:#true
#compare :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> #EQ:#GT:#LT
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
#0 :: #neg:#pos:#s:#0

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

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

   FINDMIN_1
   FINDMIN#1_1
   MINSORT_1
   MINSORT#1_1
   #LESS_2
   FINDMIN#2_2

(c) The following functions are completely defined:

   #COMPARE_2
   findMin_1
   findMin#1_1
   findMin#2_2
   findMin#3_4
   #less_2
   #cklt_1
   #compare_2

Due to the following rules being added:

   #COMPARE(v0, v1) -> const6 [0]
   findMin(v0) -> nil [0]
   findMin#1(v0) -> nil [0]
   findMin#2(v0, v1) -> nil [0]
   findMin#3(v0, v1, v2, v3) -> nil [0]
   #less(v0, v1) -> null_#less [0]
   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]

And the following fresh constants:    const6, null_#less, null_#cklt, null_#compare, const, const1, const2, const3, const4, const5

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

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

   FINDMIN(z0) -> c16(FINDMIN#1(z0)) [1]
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin(z1), z0), FINDMIN(z1)) [1]
   MINSORT(z0) -> c23(MINSORT#1(findMin(z0)), FINDMIN(z0)) [1]
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1)) [1]
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) [1]
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0)) [1]
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) [0]
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) [0]
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) [0]
   findMin(z0) -> findMin#1(z0) [0]
   findMin#1(::(z0, z1)) -> findMin#2(findMin(z1), z0) [0]
   findMin#1(nil) -> nil [0]
   findMin#2(::(z0, z1), z2) -> findMin#3(#less(z2, z0), z2, z0, z1) [0]
   findMin#2(nil, z0) -> ::(z0, nil) [0]
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2)) [0]
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2)) [0]
   #less(z0, z1) -> #cklt(#compare(z0, z1)) [0]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(z0)) -> #GT [0]
   #compare(#0, #pos(z0)) -> #LT [0]
   #compare(#0, #s(z0)) -> #LT [0]
   #compare(#neg(z0), #0) -> #LT [0]
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) [0]
   #compare(#neg(z0), #pos(z1)) -> #LT [0]
   #compare(#pos(z0), #0) -> #GT [0]
   #compare(#pos(z0), #neg(z1)) -> #GT [0]
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) [0]
   #compare(#s(z0), #0) -> #GT [0]
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1) [0]
   #COMPARE(v0, v1) -> const6 [0]
   findMin(v0) -> nil [0]
   findMin#1(v0) -> nil [0]
   findMin#2(v0, v1) -> nil [0]
   findMin#3(v0, v1, v2, v3) -> nil [0]
   #less(v0, v1) -> null_#less [0]
   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]

The TRS has the following type information:
FINDMIN :: :::nil -> c16
c16 :: c17 -> c16
FINDMIN#1 :: :::nil -> c17
:: :: #neg:#pos:#s:#0 -> :::nil -> :::nil
c17 :: c19 -> c16 -> c17
FINDMIN#2 :: :::nil -> #neg:#pos:#s:#0 -> c19
findMin :: :::nil -> :::nil
MINSORT :: :::nil -> c23
c23 :: c24 -> c16 -> c23
MINSORT#1 :: :::nil -> c24
c24 :: c23 -> c24
#LESS :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> c15
c15 :: c8:c12:c14:const6 -> c15
#COMPARE :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> c8:c12:c14:const6
c19 :: c15 -> c19
#neg :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c8 :: c8:c12:c14:const6 -> c8:c12:c14:const6
#pos :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c12 :: c8:c12:c14:const6 -> c8:c12:c14:const6
#s :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c14 :: c8:c12:c14:const6 -> c8:c12:c14:const6
findMin#1 :: :::nil -> :::nil
findMin#2 :: :::nil -> #neg:#pos:#s:#0 -> :::nil
nil :: :::nil
findMin#3 :: #false:#true:null_#less:null_#cklt -> #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> :::nil -> :::nil
#less :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> #false:#true:null_#less:null_#cklt
#false :: #false:#true:null_#less:null_#cklt
#true :: #false:#true:null_#less:null_#cklt
#cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#less:null_#cklt
#compare :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> #EQ:#GT:#LT:null_#compare
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
#0 :: #neg:#pos:#s:#0
const6 :: c8:c12:c14:const6
null_#less :: #false:#true:null_#less:null_#cklt
null_#cklt :: #false:#true:null_#less:null_#cklt
null_#compare :: #EQ:#GT:#LT:null_#compare
const :: c16
const1 :: c17
const2 :: c19
const3 :: c23
const4 :: c24
const5 :: c15

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

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

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

   FINDMIN(z0) -> c16(FINDMIN#1(z0)) [1]
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(findMin#1(z1), z0), FINDMIN(z1)) [1]
   FINDMIN#1(::(z0, z1)) -> c17(FINDMIN#2(nil, z0), FINDMIN(z1)) [1]
   MINSORT(z0) -> c23(MINSORT#1(findMin#1(z0)), FINDMIN(z0)) [1]
   MINSORT(z0) -> c23(MINSORT#1(nil), FINDMIN(z0)) [1]
   MINSORT#1(::(z0, z1)) -> c24(MINSORT(z1)) [1]
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) [1]
   FINDMIN#2(::(z0, z1), z2) -> c19(#LESS(z2, z0)) [1]
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) [0]
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) [0]
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) [0]
   findMin(z0) -> findMin#1(z0) [0]
   findMin#1(::(z0, z1)) -> findMin#2(findMin#1(z1), z0) [0]
   findMin#1(::(z0, z1)) -> findMin#2(nil, z0) [0]
   findMin#1(nil) -> nil [0]
   findMin#2(::(z0, z1), z2) -> findMin#3(#cklt(#compare(z2, z0)), z2, z0, z1) [0]
   findMin#2(::(z0, z1), z2) -> findMin#3(null_#less, z2, z0, z1) [0]
   findMin#2(nil, z0) -> ::(z0, nil) [0]
   findMin#3(#false, z0, z1, z2) -> ::(z1, ::(z0, z2)) [0]
   findMin#3(#true, z0, z1, z2) -> ::(z0, ::(z1, z2)) [0]
   #less(#0, #0) -> #cklt(#EQ) [0]
   #less(#0, #neg(z0')) -> #cklt(#GT) [0]
   #less(#0, #pos(z0'')) -> #cklt(#LT) [0]
   #less(#0, #s(z01)) -> #cklt(#LT) [0]
   #less(#neg(z02), #0) -> #cklt(#LT) [0]
   #less(#neg(z03), #neg(z1')) -> #cklt(#compare(z1', z03)) [0]
   #less(#neg(z04), #pos(z1'')) -> #cklt(#LT) [0]
   #less(#pos(z05), #0) -> #cklt(#GT) [0]
   #less(#pos(z06), #neg(z11)) -> #cklt(#GT) [0]
   #less(#pos(z07), #pos(z12)) -> #cklt(#compare(z07, z12)) [0]
   #less(#s(z08), #0) -> #cklt(#GT) [0]
   #less(#s(z09), #s(z13)) -> #cklt(#compare(z09, z13)) [0]
   #less(z0, z1) -> #cklt(null_#compare) [0]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(z0)) -> #GT [0]
   #compare(#0, #pos(z0)) -> #LT [0]
   #compare(#0, #s(z0)) -> #LT [0]
   #compare(#neg(z0), #0) -> #LT [0]
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) [0]
   #compare(#neg(z0), #pos(z1)) -> #LT [0]
   #compare(#pos(z0), #0) -> #GT [0]
   #compare(#pos(z0), #neg(z1)) -> #GT [0]
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) [0]
   #compare(#s(z0), #0) -> #GT [0]
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1) [0]
   #COMPARE(v0, v1) -> const6 [0]
   findMin(v0) -> nil [0]
   findMin#1(v0) -> nil [0]
   findMin#2(v0, v1) -> nil [0]
   findMin#3(v0, v1, v2, v3) -> nil [0]
   #less(v0, v1) -> null_#less [0]
   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]

The TRS has the following type information:
FINDMIN :: :::nil -> c16
c16 :: c17 -> c16
FINDMIN#1 :: :::nil -> c17
:: :: #neg:#pos:#s:#0 -> :::nil -> :::nil
c17 :: c19 -> c16 -> c17
FINDMIN#2 :: :::nil -> #neg:#pos:#s:#0 -> c19
findMin :: :::nil -> :::nil
MINSORT :: :::nil -> c23
c23 :: c24 -> c16 -> c23
MINSORT#1 :: :::nil -> c24
c24 :: c23 -> c24
#LESS :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> c15
c15 :: c8:c12:c14:const6 -> c15
#COMPARE :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> c8:c12:c14:const6
c19 :: c15 -> c19
#neg :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c8 :: c8:c12:c14:const6 -> c8:c12:c14:const6
#pos :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c12 :: c8:c12:c14:const6 -> c8:c12:c14:const6
#s :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0
c14 :: c8:c12:c14:const6 -> c8:c12:c14:const6
findMin#1 :: :::nil -> :::nil
findMin#2 :: :::nil -> #neg:#pos:#s:#0 -> :::nil
nil :: :::nil
findMin#3 :: #false:#true:null_#less:null_#cklt -> #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> :::nil -> :::nil
#less :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> #false:#true:null_#less:null_#cklt
#false :: #false:#true:null_#less:null_#cklt
#true :: #false:#true:null_#less:null_#cklt
#cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#less:null_#cklt
#compare :: #neg:#pos:#s:#0 -> #neg:#pos:#s:#0 -> #EQ:#GT:#LT:null_#compare
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
#0 :: #neg:#pos:#s:#0
const6 :: c8:c12:c14:const6
null_#less :: #false:#true:null_#less:null_#cklt
null_#cklt :: #false:#true:null_#less:null_#cklt
null_#compare :: #EQ:#GT:#LT:null_#compare
const :: c16
const1 :: c17
const2 :: c19
const3 :: c23
const4 :: c24
const5 :: c15

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

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

   nil => 0
   #false => 1
   #true => 2
   #EQ => 1
   #GT => 2
   #LT => 3
   #0 => 0
   const6 => 0
   null_#less => 0
   null_#cklt => 0
   null_#compare => 0
   const => 0
   const1 => 0
   const2 => 0
   const3 => 0
   const4 => 0
   const5 => 0

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z1, z0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z0, z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z0 >= 0, z' = 1 + z0, z = 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 1 + z0, z0 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #compare(z, z') -{ 0 }-> 2 :|: z0 >= 0, z' = 1 + z0, z = 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 1 + z0, z0 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #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(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #compare(z, z') -{ 0 }-> #compare(z1, z0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #less(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #less(z, z') -{ 0 }-> #cklt(3) :|: z' = 1 + z0'', z0'' >= 0, z = 0
   #less(z, z') -{ 0 }-> #cklt(3) :|: z01 >= 0, z' = 1 + z01, z = 0
   #less(z, z') -{ 0 }-> #cklt(3) :|: z = 1 + z02, z02 >= 0, z' = 0
   #less(z, z') -{ 0 }-> #cklt(3) :|: z04 >= 0, z' = 1 + z1'', z = 1 + z04, z1'' >= 0
   #less(z, z') -{ 0 }-> #cklt(2) :|: z0' >= 0, z = 0, z' = 1 + z0'
   #less(z, z') -{ 0 }-> #cklt(2) :|: z05 >= 0, z = 1 + z05, z' = 0
   #less(z, z') -{ 0 }-> #cklt(2) :|: z' = 1 + z11, z11 >= 0, z06 >= 0, z = 1 + z06
   #less(z, z') -{ 0 }-> #cklt(2) :|: z08 >= 0, z = 1 + z08, z' = 0
   #less(z, z') -{ 0 }-> #cklt(1) :|: z = 0, z' = 0
   #less(z, z') -{ 0 }-> #cklt(0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z07, z12)) :|: z' = 1 + z12, z07 >= 0, z = 1 + z07, z12 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z09, z13)) :|: z' = 1 + z13, z = 1 + z09, z09 >= 0, z13 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z1', z03)) :|: z' = 1 + z1', z1' >= 0, z = 1 + z03, z03 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z0) :|: z = z0, z0 >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z2, z0) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z0)) + FINDMIN(z0) :|: z = z0, z0 >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z0) :|: z = z0, z0 >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z0) :|: z = z0, z0 >= 0
   findMin(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   findMin#2(z, z') -{ 0 }-> findMin#3(0, z2, z0, z1) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z2, z0)), z2, z0, z1) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   findMin#2(z, z') -{ 0 }-> 1 + z0 + 0 :|: z0 >= 0, z = 0, z' = z0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z3 = v3, v2 >= 0, v3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z0 + (1 + z1 + z2) :|: z = 2, z1 >= 0, z0 >= 0, z3 = z2, z' = z0, z2 >= 0, z'' = z1
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z1 + (1 + z0 + z2) :|: z1 >= 0, z = 1, z0 >= 0, z3 = z2, z' = z0, z2 >= 0, z'' = z1


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

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

   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z3 = v3, v2 >= 0, v3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z0 + (1 + z1 + z2) :|: z = 2, z1 >= 0, z0 >= 0, z3 = z2, z' = z0, z2 >= 0, z'' = z1
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z1 + (1 + z0 + z2) :|: z1 >= 0, z = 1, z0 >= 0, z3 = z2, z' = z0, z2 >= 0, z'' = z1
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 2 :|: z = 3

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z1, z0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z0, z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z0 >= 0, z' = 1 + z0, z = 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 1 + z0, z0 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #compare(z, z') -{ 0 }-> 2 :|: z0 >= 0, z' = 1 + z0, z = 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 1 + z0, z0 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #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(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #compare(z, z') -{ 0 }-> #compare(z1, z0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   #less(z, z') -{ 0 }-> 2 :|: z' = 1 + z0'', z0'' >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z01 >= 0, z' = 1 + z01, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z = 1 + z02, z02 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z04 >= 0, z' = 1 + z1'', z = 1 + z04, z1'' >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z0' >= 0, z = 0, z' = 1 + z0', 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z05 >= 0, z = 1 + z05, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' = 1 + z11, z11 >= 0, z06 >= 0, z = 1 + z06, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z08 >= 0, z = 1 + z08, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z0' >= 0, z = 0, z' = 1 + z0', v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' = 1 + z0'', z0'' >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z01 >= 0, z' = 1 + z01, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z = 1 + z02, z02 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z04 >= 0, z' = 1 + z1'', z = 1 + z04, z1'' >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z05 >= 0, z = 1 + z05, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' = 1 + z11, z11 >= 0, z06 >= 0, z = 1 + z06, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z08 >= 0, z = 1 + z08, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(#compare(z07, z12)) :|: z' = 1 + z12, z07 >= 0, z = 1 + z07, z12 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z09, z13)) :|: z' = 1 + z13, z = 1 + z09, z09 >= 0, z13 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z1', z03)) :|: z' = 1 + z1', z1' >= 0, z = 1 + z03, z03 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z0) :|: z = z0, z0 >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z2, z0) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z0)) + FINDMIN(z0) :|: z = z0, z0 >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z0) :|: z = z0, z0 >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z0) :|: z = z0, z0 >= 0
   findMin(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z2, z0)), z2, z0, z1) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, v0 >= 0, z0 = v2, v1 >= 0, 0 = v0, z2 = v1, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z0 + 0 :|: z0 >= 0, z = 0, z' = z0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z3 = v3, v2 >= 0, v3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z0 + (1 + z1 + z2) :|: z = 2, z1 >= 0, z0 >= 0, z3 = z2, z' = z0, z2 >= 0, z'' = z1
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z1 + (1 + z0 + z2) :|: z1 >= 0, z = 1, z0 >= 0, z3 = z2, z' = z0, z2 >= 0, z'' = z1


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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(#compare(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z', z0)), z', z0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0


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

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

   { #compare }
   { findMin#3 }
   { #COMPARE }
   { #cklt }
   { #less }
   { findMin#2 }
   { #LESS }
   { findMin#1 }
   { FINDMIN#2 }
   { FINDMIN, FINDMIN#1 }
   { findMin }
   { MINSORT#1, MINSORT }

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(#compare(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z', z0)), z', z0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#compare}, {findMin#3}, {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(#compare(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z', z0)), z', z0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#compare}, {findMin#3}, {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(#compare(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z', z0)), z', z0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#compare}, {findMin#3}, {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: ?, size: O(1) [3]

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(#compare(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(#compare(z', z0)), z', z0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#3}, {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#3}, {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#3}, {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: ?, size: O(n^1) [2 + z' + z'' + z3]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#COMPARE}, {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: ?, size: O(n^1) [z + z']

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + #COMPARE(z' - 1, z - 1) :|: z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + #COMPARE(z, z') :|: z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#cklt}, {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: ?, size: O(1) [2]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 0 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> findMin#3(#cklt(s2), z', z0, z1) :|: s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#less}, {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: ?, size: O(1) [2]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#2}, {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: ?, size: O(n^1) [1 + z + z']

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(0, z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {#LESS}, {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: ?, size: O(n^1) [1 + z + z']

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 1 }-> 1 + #LESS(z', z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']

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

(73) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin#1}, {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: ?, size: O(n^1) [z]

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(findMin#1(z1), z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(findMin#1(z)) + FINDMIN(z) :|: z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> findMin#1(z) :|: z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> findMin#2(findMin#1(z1), z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(s12, z0) + FINDMIN(z1) :|: s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(s13) + FINDMIN(z) :|: s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]

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

(79) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(s12, z0) + FINDMIN(z1) :|: s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(s13) + FINDMIN(z) :|: s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {FINDMIN#2}, {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: ?, size: O(n^1) [1 + z + z']

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(s12, z0) + FINDMIN(z1) :|: s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 1 }-> 1 + FINDMIN#2(0, z0) + FINDMIN(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(s13) + FINDMIN(z) :|: s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 3 }-> 1 + s17 + FINDMIN(z1) :|: s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 3 }-> 1 + s18 + FINDMIN(z1) :|: s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(s13) + FINDMIN(z) :|: s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']

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

(85) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 3 }-> 1 + s17 + FINDMIN(z1) :|: s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 3 }-> 1 + s18 + FINDMIN(z1) :|: s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(s13) + FINDMIN(z) :|: s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {FINDMIN,FINDMIN#1}, {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: ?, size: O(1) [0]
  FINDMIN#1: runtime: ?, size: O(n^1) [1 + z]

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

(87) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 }-> 1 + FINDMIN#1(z) :|: z >= 0
   FINDMIN#1(z) -{ 3 }-> 1 + s17 + FINDMIN(z1) :|: s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 3 }-> 1 + s18 + FINDMIN(z1) :|: s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(s13) + FINDMIN(z) :|: s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 1 }-> 1 + MINSORT#1(0) + FINDMIN(z) :|: z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 + 4*z }-> 1 + s19 :|: s19 >= 0, s19 <= z + 1, z >= 0
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s17 + s20 :|: s20 >= 0, s20 <= 0, s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s18 + s21 :|: s21 >= 0, s21 <= 0, s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(s13) + s22 :|: s22 >= 0, s22 <= 0, s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(0) + s23 :|: s23 >= 0, s23 <= 0, z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]

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

(91) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 + 4*z }-> 1 + s19 :|: s19 >= 0, s19 <= z + 1, z >= 0
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s17 + s20 :|: s20 >= 0, s20 <= 0, s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s18 + s21 :|: s21 >= 0, s21 <= 0, s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(s13) + s22 :|: s22 >= 0, s22 <= 0, s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(0) + s23 :|: s23 >= 0, s23 <= 0, z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {findMin}, {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]
  findMin: runtime: ?, size: O(n^1) [z]

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

(93) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 + 4*z }-> 1 + s19 :|: s19 >= 0, s19 <= z + 1, z >= 0
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s17 + s20 :|: s20 >= 0, s20 <= 0, s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s18 + s21 :|: s21 >= 0, s21 <= 0, s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(s13) + s22 :|: s22 >= 0, s22 <= 0, s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(0) + s23 :|: s23 >= 0, s23 <= 0, z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]
  findMin: runtime: O(1) [0], size: O(n^1) [z]

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 + 4*z }-> 1 + s19 :|: s19 >= 0, s19 <= z + 1, z >= 0
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s17 + s20 :|: s20 >= 0, s20 <= 0, s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s18 + s21 :|: s21 >= 0, s21 <= 0, s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(s13) + s22 :|: s22 >= 0, s22 <= 0, s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(0) + s23 :|: s23 >= 0, s23 <= 0, z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]
  findMin: runtime: O(1) [0], size: O(n^1) [z]

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

(97) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 + 4*z }-> 1 + s19 :|: s19 >= 0, s19 <= z + 1, z >= 0
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s17 + s20 :|: s20 >= 0, s20 <= 0, s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s18 + s21 :|: s21 >= 0, s21 <= 0, s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(s13) + s22 :|: s22 >= 0, s22 <= 0, s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(0) + s23 :|: s23 >= 0, s23 <= 0, z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: {MINSORT#1,MINSORT}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]
  findMin: runtime: O(1) [0], size: O(n^1) [z]
  MINSORT#1: runtime: ?, size: O(1) [0]
  MINSORT: runtime: ?, size: O(1) [1]

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

(99) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #COMPARE(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s4 :|: s4 >= 0, s4 <= z' - 1 + (z - 1), z' - 1 >= 0, z - 1 >= 0
   #COMPARE(z, z') -{ 0 }-> 1 + s5 :|: s5 >= 0, s5 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   #LESS(z, z') -{ 1 }-> 1 + s3 :|: s3 >= 0, s3 <= z + z', z' >= 0, z >= 0
   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z' - 1 >= 0, z - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z' - 1 >= 0, z = 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' - 1 >= 0, z = 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
   #less(z, z') -{ 0 }-> s6 :|: s6 >= 0, s6 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 0 }-> s7 :|: s7 >= 0, s7 <= 2, s1 >= 0, s1 <= 3, z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0, 3 = 3
   #less(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 0 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   FINDMIN(z) -{ 1 + 4*z }-> 1 + s19 :|: s19 >= 0, s19 <= z + 1, z >= 0
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s17 + s20 :|: s20 >= 0, s20 <= 0, s17 >= 0, s17 <= s12 + z0 + 1, s12 >= 0, s12 <= z1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#1(z) -{ 4 + 4*z1 }-> 1 + s18 + s21 :|: s21 >= 0, s21 <= 0, s18 >= 0, s18 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   FINDMIN#2(z, z') -{ 2 }-> 1 + s11 :|: s11 >= 0, s11 <= z' + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(s13) + s22 :|: s22 >= 0, s22 <= 0, s13 >= 0, s13 <= z, z >= 0
   MINSORT(z) -{ 2 + 4*z }-> 1 + MINSORT#1(0) + s23 :|: s23 >= 0, s23 <= 0, z >= 0
   MINSORT#1(z) -{ 1 }-> 1 + MINSORT(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin(z) -{ 0 }-> s14 :|: s14 >= 0, s14 <= z, z >= 0
   findMin(z) -{ 0 }-> 0 :|: z >= 0
   findMin#1(z) -{ 0 }-> s10 :|: s10 >= 0, s10 <= 0 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> s16 :|: s15 >= 0, s15 <= z1, s16 >= 0, s16 <= s15 + z0 + 1, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   findMin#1(z) -{ 0 }-> 0 :|: z = 0
   findMin#1(z) -{ 0 }-> 0 :|: z >= 0
   findMin#2(z, z') -{ 0 }-> s9 :|: s8 >= 0, s8 <= 2, s9 >= 0, s9 <= z' + z0 + z1 + 2, s2 >= 0, s2 <= 3, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   findMin#2(z, z') -{ 0 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0, v0 >= 0, z0 = v2, 0 = v0, z1 = v3, v2 >= 0, v3 >= 0
   findMin#2(z, z') -{ 0 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z' + (1 + z'' + z3) :|: z = 2, z'' >= 0, z' >= 0, z3 >= 0
   findMin#3(z, z', z'', z3) -{ 0 }-> 1 + z'' + (1 + z' + z3) :|: z'' >= 0, z = 1, z' >= 0, z3 >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  findMin#3: runtime: O(1) [0], size: O(n^1) [2 + z' + z'' + z3]
  #COMPARE: runtime: O(1) [0], size: O(n^1) [z + z']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [0], size: O(1) [2]
  findMin#2: runtime: O(1) [0], size: O(n^1) [1 + z + z']
  #LESS: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  findMin#1: runtime: O(1) [0], size: O(n^1) [z]
  FINDMIN#2: runtime: O(1) [2], size: O(n^1) [1 + z + z']
  FINDMIN: runtime: O(n^1) [1 + 4*z], size: O(1) [0]
  FINDMIN#1: runtime: O(n^1) [4*z], size: O(n^1) [1 + z]
  findMin: runtime: O(1) [0], size: O(n^1) [z]
  MINSORT#1: runtime: O(n^2) [10*z + 16*z^2], size: O(1) [0]
  MINSORT: runtime: O(n^2) [4 + 18*z + 16*z^2], size: O(1) [1]

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

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

(102)
BOUNDS(1, n^2)