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


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

(0) CpxTRS
(1) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(2) CpxWeightedTrs
(3) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
(4) CpxTypedWeightedTrs
(5) CompletionProof [UPPER BOUND(ID), 0 ms]
(6) CpxTypedWeightedCompleteTrs
(7) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
(8) CpxTypedWeightedCompleteTrs
(9) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
(10) CpxRNTS
(11) InliningProof [UPPER BOUND(ID), 828 ms]
(12) CpxRNTS
(13) SimplificationProof [BOTH BOUNDS(ID, ID), 10 ms]
(14) CpxRNTS
(15) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
(16) CpxRNTS
(17) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(18) CpxRNTS
(19) IntTrsBoundProof [UPPER BOUND(ID), 227 ms]
(20) CpxRNTS
(21) IntTrsBoundProof [UPPER BOUND(ID), 46 ms]
(22) CpxRNTS
(23) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(24) CpxRNTS
(25) IntTrsBoundProof [UPPER BOUND(ID), 141 ms]
(26) CpxRNTS
(27) IntTrsBoundProof [UPPER BOUND(ID), 54 ms]
(28) CpxRNTS
(29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(30) CpxRNTS
(31) IntTrsBoundProof [UPPER BOUND(ID), 129 ms]
(32) CpxRNTS
(33) IntTrsBoundProof [UPPER BOUND(ID), 43 ms]
(34) CpxRNTS
(35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(36) CpxRNTS
(37) IntTrsBoundProof [UPPER BOUND(ID), 7 ms]
(38) CpxRNTS
(39) IntTrsBoundProof [UPPER BOUND(ID), 13 ms]
(40) CpxRNTS
(41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(42) CpxRNTS
(43) IntTrsBoundProof [UPPER BOUND(ID), 138 ms]
(44) CpxRNTS
(45) IntTrsBoundProof [UPPER BOUND(ID), 42 ms]
(46) CpxRNTS
(47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(48) CpxRNTS
(49) IntTrsBoundProof [UPPER BOUND(ID), 202 ms]
(50) CpxRNTS
(51) IntTrsBoundProof [UPPER BOUND(ID), 54 ms]
(52) CpxRNTS
(53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(54) CpxRNTS
(55) IntTrsBoundProof [UPPER BOUND(ID), 406 ms]
(56) CpxRNTS
(57) IntTrsBoundProof [UPPER BOUND(ID), 85 ms]
(58) CpxRNTS
(59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(60) CpxRNTS
(61) IntTrsBoundProof [UPPER BOUND(ID), 1665 ms]
(62) CpxRNTS
(63) IntTrsBoundProof [UPPER BOUND(ID), 414 ms]
(64) CpxRNTS
(65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(66) CpxRNTS
(67) IntTrsBoundProof [UPPER BOUND(ID), 1038 ms]
(68) CpxRNTS
(69) IntTrsBoundProof [UPPER BOUND(ID), 8 ms]
(70) CpxRNTS
(71) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(72) CpxRNTS
(73) IntTrsBoundProof [UPPER BOUND(ID), 1112 ms]
(74) CpxRNTS
(75) IntTrsBoundProof [UPPER BOUND(ID), 31 ms]
(76) CpxRNTS
(77) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
(78) CpxRNTS
(79) IntTrsBoundProof [UPPER BOUND(ID), 628 ms]
(80) CpxRNTS
(81) IntTrsBoundProof [UPPER BOUND(ID), 62 ms]
(82) CpxRNTS
(83) FinalProof [FINISHED, 0 ms]
(84) BOUNDS(1, n^1)


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

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


The TRS R consists of the following rules:

   natsFrom(N) -> cons(N, n__natsFrom(s(N)))
   fst(pair(XS, YS)) -> XS
   snd(pair(XS, YS)) -> YS
   splitAt(0, XS) -> pair(nil, XS)
   splitAt(s(N), cons(X, XS)) -> u(splitAt(N, activate(XS)), N, X, activate(XS))
   u(pair(YS, ZS), N, X, XS) -> pair(cons(activate(X), YS), ZS)
   head(cons(N, XS)) -> N
   tail(cons(N, XS)) -> activate(XS)
   sel(N, XS) -> head(afterNth(N, XS))
   take(N, XS) -> fst(splitAt(N, XS))
   afterNth(N, XS) -> snd(splitAt(N, XS))
   natsFrom(X) -> n__natsFrom(X)
   activate(n__natsFrom(X)) -> natsFrom(X)
   activate(X) -> X

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

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

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


The TRS R consists of the following rules:

   natsFrom(N) -> cons(N, n__natsFrom(s(N))) [1]
   fst(pair(XS, YS)) -> XS [1]
   snd(pair(XS, YS)) -> YS [1]
   splitAt(0, XS) -> pair(nil, XS) [1]
   splitAt(s(N), cons(X, XS)) -> u(splitAt(N, activate(XS)), N, X, activate(XS)) [1]
   u(pair(YS, ZS), N, X, XS) -> pair(cons(activate(X), YS), ZS) [1]
   head(cons(N, XS)) -> N [1]
   tail(cons(N, XS)) -> activate(XS) [1]
   sel(N, XS) -> head(afterNth(N, XS)) [1]
   take(N, XS) -> fst(splitAt(N, XS)) [1]
   afterNth(N, XS) -> snd(splitAt(N, XS)) [1]
   natsFrom(X) -> n__natsFrom(X) [1]
   activate(n__natsFrom(X)) -> natsFrom(X) [1]
   activate(X) -> X [1]

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

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

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

   natsFrom(N) -> cons(N, n__natsFrom(s(N))) [1]
   fst(pair(XS, YS)) -> XS [1]
   snd(pair(XS, YS)) -> YS [1]
   splitAt(0, XS) -> pair(nil, XS) [1]
   splitAt(s(N), cons(X, XS)) -> u(splitAt(N, activate(XS)), N, X, activate(XS)) [1]
   u(pair(YS, ZS), N, X, XS) -> pair(cons(activate(X), YS), ZS) [1]
   head(cons(N, XS)) -> N [1]
   tail(cons(N, XS)) -> activate(XS) [1]
   sel(N, XS) -> head(afterNth(N, XS)) [1]
   take(N, XS) -> fst(splitAt(N, XS)) [1]
   afterNth(N, XS) -> snd(splitAt(N, XS)) [1]
   natsFrom(X) -> n__natsFrom(X) [1]
   activate(n__natsFrom(X)) -> natsFrom(X) [1]
   activate(X) -> X [1]

The TRS has the following type information:
natsFrom :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
cons :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
n__natsFrom :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
s :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
fst :: pair -> s:n__natsFrom:cons:0:nil
pair :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> pair
snd :: pair -> s:n__natsFrom:cons:0:nil
splitAt :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> pair
0 :: s:n__natsFrom:cons:0:nil
nil :: s:n__natsFrom:cons:0:nil
u :: pair -> s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> pair
activate :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
head :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
tail :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
sel :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
afterNth :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil
take :: s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil -> s:n__natsFrom:cons:0:nil

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

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

   fst_1
   head_1
   tail_1
   sel_2
   take_2

(c) The following functions are completely defined:

   splitAt_2
   activate_1
   afterNth_2
   natsFrom_1
   snd_1
   u_4

Due to the following rules being added:

   splitAt(v0, v1) -> const [0]
   snd(v0) -> null_snd [0]
   u(v0, v1, v2, v3) -> const [0]

And the following fresh constants:    const, null_snd

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

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

   natsFrom(N) -> cons(N, n__natsFrom(s(N))) [1]
   fst(pair(XS, YS)) -> XS [1]
   snd(pair(XS, YS)) -> YS [1]
   splitAt(0, XS) -> pair(nil, XS) [1]
   splitAt(s(N), cons(X, XS)) -> u(splitAt(N, activate(XS)), N, X, activate(XS)) [1]
   u(pair(YS, ZS), N, X, XS) -> pair(cons(activate(X), YS), ZS) [1]
   head(cons(N, XS)) -> N [1]
   tail(cons(N, XS)) -> activate(XS) [1]
   sel(N, XS) -> head(afterNth(N, XS)) [1]
   take(N, XS) -> fst(splitAt(N, XS)) [1]
   afterNth(N, XS) -> snd(splitAt(N, XS)) [1]
   natsFrom(X) -> n__natsFrom(X) [1]
   activate(n__natsFrom(X)) -> natsFrom(X) [1]
   activate(X) -> X [1]
   splitAt(v0, v1) -> const [0]
   snd(v0) -> null_snd [0]
   u(v0, v1, v2, v3) -> const [0]

The TRS has the following type information:
natsFrom :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
cons :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
n__natsFrom :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
s :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
fst :: pair:const -> s:n__natsFrom:cons:0:nil:null_snd
pair :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> pair:const
snd :: pair:const -> s:n__natsFrom:cons:0:nil:null_snd
splitAt :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> pair:const
0 :: s:n__natsFrom:cons:0:nil:null_snd
nil :: s:n__natsFrom:cons:0:nil:null_snd
u :: pair:const -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> pair:const
activate :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
head :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
tail :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
sel :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
afterNth :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
take :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
const :: pair:const
null_snd :: s:n__natsFrom:cons:0:nil:null_snd

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

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

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

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

   natsFrom(N) -> cons(N, n__natsFrom(s(N))) [1]
   fst(pair(XS, YS)) -> XS [1]
   snd(pair(XS, YS)) -> YS [1]
   splitAt(0, XS) -> pair(nil, XS) [1]
   splitAt(s(N), cons(X, n__natsFrom(X'))) -> u(splitAt(N, natsFrom(X')), N, X, natsFrom(X')) [3]
   splitAt(s(N), cons(X, n__natsFrom(X'))) -> u(splitAt(N, natsFrom(X')), N, X, n__natsFrom(X')) [3]
   splitAt(s(N), cons(X, n__natsFrom(X''))) -> u(splitAt(N, n__natsFrom(X'')), N, X, natsFrom(X'')) [3]
   splitAt(s(N), cons(X, XS)) -> u(splitAt(N, XS), N, X, XS) [3]
   u(pair(YS, ZS), N, X, XS) -> pair(cons(activate(X), YS), ZS) [1]
   head(cons(N, XS)) -> N [1]
   tail(cons(N, XS)) -> activate(XS) [1]
   sel(N, XS) -> head(snd(splitAt(N, XS))) [2]
   take(0, XS) -> fst(pair(nil, XS)) [2]
   take(s(N'), cons(X1, XS')) -> fst(u(splitAt(N', activate(XS')), N', X1, activate(XS'))) [2]
   take(N, XS) -> fst(const) [1]
   afterNth(0, XS) -> snd(pair(nil, XS)) [2]
   afterNth(s(N''), cons(X2, XS'')) -> snd(u(splitAt(N'', activate(XS'')), N'', X2, activate(XS''))) [2]
   afterNth(N, XS) -> snd(const) [1]
   natsFrom(X) -> n__natsFrom(X) [1]
   activate(n__natsFrom(X)) -> natsFrom(X) [1]
   activate(X) -> X [1]
   splitAt(v0, v1) -> const [0]
   snd(v0) -> null_snd [0]
   u(v0, v1, v2, v3) -> const [0]

The TRS has the following type information:
natsFrom :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
cons :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
n__natsFrom :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
s :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
fst :: pair:const -> s:n__natsFrom:cons:0:nil:null_snd
pair :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> pair:const
snd :: pair:const -> s:n__natsFrom:cons:0:nil:null_snd
splitAt :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> pair:const
0 :: s:n__natsFrom:cons:0:nil:null_snd
nil :: s:n__natsFrom:cons:0:nil:null_snd
u :: pair:const -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> pair:const
activate :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
head :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
tail :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
sel :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
afterNth :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
take :: s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd -> s:n__natsFrom:cons:0:nil:null_snd
const :: pair:const
null_snd :: s:n__natsFrom:cons:0:nil:null_snd

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

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

   0 => 0
   nil => 1
   const => 0
   null_snd => 0

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

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

   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 1 }-> natsFrom(X) :|: z = 1 + X, X >= 0
   afterNth(z, z') -{ 2 }-> snd(u(splitAt(N'', activate(XS'')), N'', X2, activate(XS''))) :|: z' = 1 + X2 + XS'', XS'' >= 0, N'' >= 0, X2 >= 0, z = 1 + N''
   afterNth(z, z') -{ 1 }-> snd(0) :|: z' = XS, z = N, XS >= 0, N >= 0
   afterNth(z, z') -{ 2 }-> snd(1 + 1 + XS) :|: z' = XS, z = 0, XS >= 0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   natsFrom(z) -{ 1 }-> 1 + N + (1 + (1 + N)) :|: z = N, N >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(N, XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   splitAt(z, z') -{ 3 }-> u(splitAt(N, XS), N, X, XS) :|: z = 1 + N, z' = 1 + X + XS, X >= 0, XS >= 0, N >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(N, natsFrom(X')), N, X, natsFrom(X')) :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(N, natsFrom(X')), N, X, 1 + X') :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(N, 1 + X''), N, X, natsFrom(X'')) :|: z' = 1 + X + (1 + X''), z = 1 + N, X >= 0, X'' >= 0, N >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   splitAt(z, z') -{ 1 }-> 1 + 1 + XS :|: z' = XS, z = 0, XS >= 0
   tail(z) -{ 1 }-> activate(XS) :|: z = 1 + N + XS, XS >= 0, N >= 0
   take(z, z') -{ 2 }-> fst(u(splitAt(N', activate(XS')), N', X1, activate(XS'))) :|: X1 >= 0, z = 1 + N', XS' >= 0, z' = 1 + X1 + XS', N' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' = XS, z = N, XS >= 0, N >= 0
   take(z, z') -{ 2 }-> fst(1 + 1 + XS) :|: z' = XS, z = 0, XS >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   u(z, z', z'', z1) -{ 1 }-> 1 + (1 + activate(X) + YS) + ZS :|: z = 1 + YS + ZS, z'' = X, YS >= 0, X >= 0, z' = N, z1 = XS, ZS >= 0, XS >= 0, N >= 0


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

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

   natsFrom(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   natsFrom(z) -{ 1 }-> 1 + N + (1 + (1 + N)) :|: z = N, N >= 0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   activate(z) -{ 1 }-> natsFrom(X) :|: z = 1 + X, X >= 0
   activate(z) -{ 1 }-> X :|: X >= 0, z = X

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

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

   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 2 }-> 1 + X' :|: z = 1 + X, X >= 0, X' >= 0, X = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z = 1 + X, X >= 0, X = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z' = XS, z = 0, XS >= 0, 1 + 1 + XS = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(N'', X), N'', X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, N'' >= 0, X2 >= 0, z = 1 + N'', X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(N'', X), N'', X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, N'' >= 0, X2 >= 0, z = 1 + N'', X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(N'', natsFrom(X)), N'', X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, N'' >= 0, X2 >= 0, z = 1 + N'', XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(N'', natsFrom(X)), N'', X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, N'' >= 0, X2 >= 0, z = 1 + N'', XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 2 }-> 0 :|: z' = XS, z = 0, XS >= 0, v0 >= 0, 1 + 1 + XS = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' = XS, z = N, XS >= 0, N >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   natsFrom(z) -{ 1 }-> 1 + N + (1 + (1 + N)) :|: z = N, N >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(N, XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   splitAt(z, z') -{ 3 }-> u(splitAt(N, XS), N, X, XS) :|: z = 1 + N, z' = 1 + X + XS, X >= 0, XS >= 0, N >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(N, 1 + X''), N, X, 1 + X') :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(N, 1 + X''), N, X, 1 + X') :|: z' = 1 + X + (1 + X''), z = 1 + N, X >= 0, X'' >= 0, N >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(N, 1 + X''), N, X, 1 + X1) :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(N, 1 + X''), N, X, 1 + N' + (1 + (1 + N'))) :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(N, 1 + X''), N, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), z = 1 + N, X >= 0, X'' >= 0, N >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(N, 1 + N' + (1 + (1 + N'))), N, X, 1 + X') :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(N, 1 + N' + (1 + (1 + N'))), N, X, 1 + X'') :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(N, 1 + N' + (1 + (1 + N'))), N, X, 1 + N'' + (1 + (1 + N''))) :|: z = 1 + N, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, N >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   splitAt(z, z') -{ 1 }-> 1 + 1 + XS :|: z' = XS, z = 0, XS >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 2 }-> natsFrom(X) :|: z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z' = XS, z = 0, XS >= 0, 1 + 1 + XS = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(N', X), N', X1, X')) :|: X1 >= 0, z = 1 + N', XS' >= 0, z' = 1 + X1 + XS', N' >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(N', X), N', X1, natsFrom(X'))) :|: X1 >= 0, z = 1 + N', XS' >= 0, z' = 1 + X1 + XS', N' >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(N', natsFrom(X)), N', X1, X')) :|: X1 >= 0, z = 1 + N', XS' >= 0, z' = 1 + X1 + XS', N' >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(N', natsFrom(X)), N', X1, natsFrom(X'))) :|: X1 >= 0, z = 1 + N', XS' >= 0, z' = 1 + X1 + XS', N' >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' = XS, z = N, XS >= 0, N >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + X' + YS) + ZS :|: z = 1 + YS + ZS, z'' = X, YS >= 0, X >= 0, z' = N, z1 = XS, ZS >= 0, XS >= 0, N >= 0, X' >= 0, X = X'
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + natsFrom(X') + YS) + ZS :|: z = 1 + YS + ZS, z'' = X, YS >= 0, X >= 0, z' = N, z1 = XS, ZS >= 0, XS >= 0, N >= 0, X = 1 + X', X' >= 0


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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 2 }-> natsFrom(X) :|: z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + natsFrom(z'' - 1) + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0


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

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

   { natsFrom }
   { snd }
   { fst }
   { activate }
   { head }
   { tail }
   { u }
   { splitAt }
   { take }
   { afterNth }
   { sel }

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 2 }-> natsFrom(X) :|: z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + natsFrom(z'' - 1) + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0

Function symbols to be analyzed: {natsFrom}, {snd}, {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 2 }-> natsFrom(X) :|: z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + natsFrom(z'' - 1) + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0

Function symbols to be analyzed: {natsFrom}, {snd}, {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}

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

(19) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 2 }-> natsFrom(X) :|: z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + natsFrom(z'' - 1) + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0

Function symbols to be analyzed: {natsFrom}, {snd}, {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: ?, size: O(n^1) [3 + 2*z]

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

(21) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, natsFrom(X)), z - 1, X2, natsFrom(X'))) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 2 }-> natsFrom(X) :|: z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, natsFrom(X)), z - 1, X1, natsFrom(X'))) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + natsFrom(z'' - 1) + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0

Function symbols to be analyzed: {snd}, {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {snd}, {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {snd}, {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: ?, size: O(n^1) [z]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {fst}, {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: ?, size: O(n^1) [z]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ 1 }-> fst(0) :|: z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {activate}, {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: ?, size: O(n^1) [1 + 2*z]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: activate
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 5

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {head}, {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: ?, size: O(n^1) [z]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [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:

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {tail}, {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: ?, size: O(n^1) [2*z]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {u}, {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: ?, size: O(n^1) [2 + z + 2*z'']

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: splitAt
after applying outer abstraction to obtain an ITS,
resulting in: EXP with polynomial bound: ?

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {splitAt}, {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: ?, size: EXP

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ 4 }-> snd(u(splitAt(z - 1, X), z - 1, X2, X')) :|: z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, X), z - 1, X2, s7)) :|: s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 6 }-> snd(u(splitAt(z - 1, s4), z - 1, X2, s5)) :|: s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ 5 }-> snd(u(splitAt(z - 1, s6), z - 1, X2, X')) :|: s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 2 }-> head(snd(splitAt(z, z'))) :|: z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ 3 }-> u(splitAt(z - 1, XS), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + X1) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + X''), z - 1, X, 1 + N' + (1 + (1 + N'))) :|: z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 4 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + X'') :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ 5 }-> u(splitAt(z - 1, 1 + N' + (1 + (1 + N'))), z - 1, X, 1 + N'' + (1 + (1 + N''))) :|: z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   take(z, z') -{ 4 }-> fst(u(splitAt(z - 1, X), z - 1, X1, X')) :|: X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, X), z - 1, X1, s3)) :|: s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ 6 }-> fst(u(splitAt(z - 1, s''), z - 1, X1, s1)) :|: s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ 5 }-> fst(u(splitAt(z - 1, s2), z - 1, X1, X')) :|: s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {take}, {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: ?, size: INF

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF

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

(73) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {afterNth}, {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF
  afterNth: runtime: ?, size: INF

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF
  afterNth: runtime: O(n^1) [6 + 264*z], size: INF

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF
  afterNth: runtime: O(n^1) [6 + 264*z], size: INF

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

(79) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: {sel}
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF
  afterNth: runtime: O(n^1) [6 + 264*z], size: INF
  sel: runtime: ?, size: INF

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> 1 + N + (1 + (1 + N)) :|: z - 1 >= 0, z - 1 = N, N >= 0
   afterNth(z, z') -{ 3 }-> YS :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   afterNth(z, z') -{ -55 + 66*z }-> s44 :|: s42 >= 0, s42 <= inf12, s43 >= 0, s43 <= s42 + 2 * X2 + 2, s44 >= 0, s44 <= s43, s4 >= 0, s4 <= 2 * X + 3, s5 >= 0, s5 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -56 + 66*z }-> s47 :|: s45 >= 0, s45 <= inf13, s46 >= 0, s46 <= s45 + 2 * X2 + 2, s47 >= 0, s47 <= s46, s6 >= 0, s6 <= 2 * X + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, XS'' = 1 + X, X >= 0, X' >= 0, XS'' = X'
   afterNth(z, z') -{ -56 + 66*z }-> s50 :|: s48 >= 0, s48 <= inf14, s49 >= 0, s49 <= s48 + 2 * X2 + 2, s50 >= 0, s50 <= s49, s7 >= 0, s7 <= 2 * X' + 3, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, XS'' = 1 + X', X' >= 0
   afterNth(z, z') -{ -57 + 66*z }-> s53 :|: s51 >= 0, s51 <= inf15, s52 >= 0, s52 <= s51 + 2 * X2 + 2, s53 >= 0, s53 <= s52, z' = 1 + X2 + XS'', XS'' >= 0, z - 1 >= 0, X2 >= 0, X >= 0, XS'' = X, X' >= 0, XS'' = X'
   afterNth(z, z') -{ 2 }-> 0 :|: z = 0, z' >= 0, v0 >= 0, 1 + 1 + z' = v0
   afterNth(z, z') -{ 1 }-> 0 :|: z' >= 0, z >= 0, v0 >= 0, 0 = v0
   fst(z) -{ 1 }-> XS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   head(z) -{ 1 }-> N :|: z = 1 + N + XS, XS >= 0, N >= 0
   natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   natsFrom(z) -{ 1 }-> 1 + z + (1 + (1 + z)) :|: z >= 0
   sel(z, z') -{ 5 + 66*z }-> s29 :|: s27 >= 0, s27 <= inf7, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z' >= 0, z >= 0
   snd(z) -{ 1 }-> YS :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   snd(z) -{ 0 }-> 0 :|: z >= 0
   splitAt(z, z') -{ -59 + 66*z }-> s10 :|: s9 >= 0, s9 <= inf, s10 >= 0, s10 <= s9 + 2 * X + 2, z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s12 :|: s11 >= 0, s11 <= inf', s12 >= 0, s12 <= s11 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X1 >= 0, X' = X1
   splitAt(z, z') -{ -57 + 66*z }-> s14 :|: s13 >= 0, s13 <= inf'', s14 >= 0, s14 <= s13 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X'', X' = N', N' >= 0
   splitAt(z, z') -{ -57 + 66*z }-> s16 :|: s15 >= 0, s15 <= inf1, s16 >= 0, s16 <= s15 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -57 + 66*z }-> s18 :|: s17 >= 0, s17 <= inf2, s18 >= 0, s18 <= s17 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0, X' = N'', N'' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s20 :|: s19 >= 0, s19 <= inf3, s20 >= 0, s20 <= s19 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X'' >= 0, X' = X''
   splitAt(z, z') -{ -58 + 66*z }-> s22 :|: s21 >= 0, s21 <= inf4, s22 >= 0, s22 <= s21 + 2 * X + 2, z' = 1 + X + (1 + X'), X >= 0, X' >= 0, z - 1 >= 0, X' = N', N' >= 0
   splitAt(z, z') -{ -58 + 66*z }-> s24 :|: s23 >= 0, s23 <= inf5, s24 >= 0, s24 <= s23 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X' >= 0, X'' = X'
   splitAt(z, z') -{ -58 + 66*z }-> s26 :|: s25 >= 0, s25 <= inf6, s26 >= 0, s26 <= s25 + 2 * X + 2, z' = 1 + X + (1 + X''), X >= 0, X'' >= 0, z - 1 >= 0, X'' = N', N' >= 0
   splitAt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   splitAt(z, z') -{ 1 }-> 1 + 1 + z' :|: z = 0, z' >= 0
   tail(z) -{ 2 }-> X :|: z = 1 + N + XS, XS >= 0, N >= 0, X >= 0, XS = X
   tail(z) -{ 3 }-> s' :|: s' >= 0, s' <= 2 * X + 3, z = 1 + N + XS, XS >= 0, N >= 0, XS = 1 + X, X >= 0
   take(z, z') -{ 3 }-> XS' :|: z = 0, z' >= 0, 1 + 1 + z' = 1 + XS' + YS, YS >= 0, XS' >= 0
   take(z, z') -{ -55 + 66*z }-> s32 :|: s30 >= 0, s30 <= inf8, s31 >= 0, s31 <= s30 + 2 * X1 + 2, s32 >= 0, s32 <= s31, s'' >= 0, s'' <= 2 * X + 3, s1 >= 0, s1 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, XS' = 1 + X', X' >= 0
   take(z, z') -{ -56 + 66*z }-> s35 :|: s33 >= 0, s33 <= inf9, s34 >= 0, s34 <= s33 + 2 * X1 + 2, s35 >= 0, s35 <= s34, s2 >= 0, s2 <= 2 * X + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, XS' = 1 + X, X >= 0, X' >= 0, XS' = X'
   take(z, z') -{ -56 + 66*z }-> s38 :|: s36 >= 0, s36 <= inf10, s37 >= 0, s37 <= s36 + 2 * X1 + 2, s38 >= 0, s38 <= s37, s3 >= 0, s3 <= 2 * X' + 3, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, XS' = 1 + X', X' >= 0
   take(z, z') -{ -57 + 66*z }-> s41 :|: s39 >= 0, s39 <= inf11, s40 >= 0, s40 <= s39 + 2 * X1 + 2, s41 >= 0, s41 <= s40, X1 >= 0, XS' >= 0, z' = 1 + X1 + XS', z - 1 >= 0, X >= 0, XS' = X, X' >= 0, XS' = X'
   take(z, z') -{ 2 }-> s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z >= 0
   u(z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   u(z, z', z'', z1) -{ 3 }-> 1 + (1 + s + YS) + ZS :|: s >= 0, s <= 2 * (z'' - 1) + 3, z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0, z'' - 1 >= 0
   u(z, z', z'', z1) -{ 2 }-> 1 + (1 + z'' + YS) + ZS :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  natsFrom: runtime: O(1) [1], size: O(n^1) [3 + 2*z]
  snd: runtime: O(1) [1], size: O(n^1) [z]
  fst: runtime: O(1) [1], size: O(n^1) [z]
  activate: runtime: O(1) [5], size: O(n^1) [1 + 2*z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  tail: runtime: O(1) [3], size: O(n^1) [2*z]
  u: runtime: O(1) [3], size: O(n^1) [2 + z + 2*z'']
  splitAt: runtime: O(n^1) [1 + 66*z], size: EXP
  take: runtime: O(n^1) [5 + 264*z], size: INF
  afterNth: runtime: O(n^1) [6 + 264*z], size: INF
  sel: runtime: O(n^1) [5 + 66*z], size: INF

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

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

(84)
BOUNDS(1, n^1)