* Step 1: Sum WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            0() -> n__0()
            U101(tt(),N,XS) -> fst(splitAt(activate(N),activate(XS)))
            U11(tt(),N,XS) -> snd(splitAt(activate(N),activate(XS)))
            U21(tt(),X) -> activate(X)
            U31(tt(),N) -> activate(N)
            U41(tt(),N) -> cons(activate(N),n__natsFrom(n__s(activate(N))))
            U51(tt(),N,XS) -> head(afterNth(activate(N),activate(XS)))
            U61(tt(),Y) -> activate(Y)
            U71(tt(),XS) -> pair(nil(),activate(XS))
            U81(tt(),N,X,XS) -> U82(splitAt(activate(N),activate(XS)),activate(X))
            U82(pair(YS,ZS),X) -> pair(cons(activate(X),YS),ZS)
            U91(tt(),XS) -> activate(XS)
            activate(X) -> X
            activate(n__0()) -> 0()
            activate(n__afterNth(X1,X2)) -> afterNth(activate(X1),activate(X2))
            activate(n__and(X1,X2)) -> and(activate(X1),X2)
            activate(n__cons(X1,X2)) -> cons(activate(X1),X2)
            activate(n__fst(X)) -> fst(activate(X))
            activate(n__head(X)) -> head(activate(X))
            activate(n__isLNat(X)) -> isLNat(X)
            activate(n__isNatural(X)) -> isNatural(X)
            activate(n__natsFrom(X)) -> natsFrom(activate(X))
            activate(n__nil()) -> nil()
            activate(n__pair(X1,X2)) -> pair(activate(X1),activate(X2))
            activate(n__s(X)) -> s(activate(X))
            activate(n__sel(X1,X2)) -> sel(activate(X1),activate(X2))
            activate(n__snd(X)) -> snd(activate(X))
            activate(n__splitAt(X1,X2)) -> splitAt(activate(X1),activate(X2))
            activate(n__tail(X)) -> tail(activate(X))
            activate(n__take(X1,X2)) -> take(activate(X1),activate(X2))
            afterNth(N,XS) -> U11(and(isNatural(N),n__isLNat(XS)),N,XS)
            afterNth(X1,X2) -> n__afterNth(X1,X2)
            and(X1,X2) -> n__and(X1,X2)
            and(tt(),X) -> activate(X)
            cons(X1,X2) -> n__cons(X1,X2)
            fst(X) -> n__fst(X)
            fst(pair(X,Y)) -> U21(and(isLNat(X),n__isLNat(Y)),X)
            head(X) -> n__head(X)
            head(cons(N,XS)) -> U31(and(isNatural(N),n__isLNat(activate(XS))),N)
            isLNat(X) -> n__isLNat(X)
            isLNat(n__afterNth(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isLNat(n__cons(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isLNat(n__fst(V1)) -> isPLNat(activate(V1))
            isLNat(n__natsFrom(V1)) -> isNatural(activate(V1))
            isLNat(n__nil()) -> tt()
            isLNat(n__snd(V1)) -> isPLNat(activate(V1))
            isLNat(n__tail(V1)) -> isLNat(activate(V1))
            isLNat(n__take(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isNatural(X) -> n__isNatural(X)
            isNatural(n__0()) -> tt()
            isNatural(n__head(V1)) -> isLNat(activate(V1))
            isNatural(n__s(V1)) -> isNatural(activate(V1))
            isNatural(n__sel(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isPLNat(n__pair(V1,V2)) -> and(isLNat(activate(V1)),n__isLNat(activate(V2)))
            isPLNat(n__splitAt(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            natsFrom(N) -> U41(isNatural(N),N)
            natsFrom(X) -> n__natsFrom(X)
            nil() -> n__nil()
            pair(X1,X2) -> n__pair(X1,X2)
            s(X) -> n__s(X)
            sel(N,XS) -> U51(and(isNatural(N),n__isLNat(XS)),N,XS)
            sel(X1,X2) -> n__sel(X1,X2)
            snd(X) -> n__snd(X)
            snd(pair(X,Y)) -> U61(and(isLNat(X),n__isLNat(Y)),Y)
            splitAt(X1,X2) -> n__splitAt(X1,X2)
            splitAt(0(),XS) -> U71(isLNat(XS),XS)
            splitAt(s(N),cons(X,XS)) -> U81(and(isNatural(N),n__and(n__isNatural(X),n__isLNat(activate(XS))))
                                           ,N
                                           ,X
                                           ,activate(XS))
            tail(X) -> n__tail(X)
            tail(cons(N,XS)) -> U91(and(isNatural(N),n__isLNat(activate(XS))),activate(XS))
            take(N,XS) -> U101(and(isNatural(N),n__isLNat(XS)),N,XS)
            take(X1,X2) -> n__take(X1,X2)
        - Signature:
            {0/0,U101/3,U11/3,U21/2,U31/2,U41/2,U51/3,U61/2,U71/2,U81/4,U82/2,U91/2,activate/1,afterNth/2,and/2,cons/2
            ,fst/1,head/1,isLNat/1,isNatural/1,isPLNat/1,natsFrom/1,nil/0,pair/2,s/1,sel/2,snd/1,splitAt/2,tail/1
            ,take/2} / {n__0/0,n__afterNth/2,n__and/2,n__cons/2,n__fst/1,n__head/1,n__isLNat/1,n__isNatural/1
            ,n__natsFrom/1,n__nil/0,n__pair/2,n__s/1,n__sel/2,n__snd/1,n__splitAt/2,n__tail/1,n__take/2,tt/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {0,U101,U11,U21,U31,U41,U51,U61,U71,U81,U82,U91,activate
            ,afterNth,and,cons,fst,head,isLNat,isNatural,isPLNat,natsFrom,nil,pair,s,sel,snd,splitAt,tail
            ,take} and constructors {n__0,n__afterNth,n__and,n__cons,n__fst,n__head,n__isLNat,n__isNatural,n__natsFrom
            ,n__nil,n__pair,n__s,n__sel,n__snd,n__splitAt,n__tail,n__take,tt}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 2: DecreasingLoops WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            0() -> n__0()
            U101(tt(),N,XS) -> fst(splitAt(activate(N),activate(XS)))
            U11(tt(),N,XS) -> snd(splitAt(activate(N),activate(XS)))
            U21(tt(),X) -> activate(X)
            U31(tt(),N) -> activate(N)
            U41(tt(),N) -> cons(activate(N),n__natsFrom(n__s(activate(N))))
            U51(tt(),N,XS) -> head(afterNth(activate(N),activate(XS)))
            U61(tt(),Y) -> activate(Y)
            U71(tt(),XS) -> pair(nil(),activate(XS))
            U81(tt(),N,X,XS) -> U82(splitAt(activate(N),activate(XS)),activate(X))
            U82(pair(YS,ZS),X) -> pair(cons(activate(X),YS),ZS)
            U91(tt(),XS) -> activate(XS)
            activate(X) -> X
            activate(n__0()) -> 0()
            activate(n__afterNth(X1,X2)) -> afterNth(activate(X1),activate(X2))
            activate(n__and(X1,X2)) -> and(activate(X1),X2)
            activate(n__cons(X1,X2)) -> cons(activate(X1),X2)
            activate(n__fst(X)) -> fst(activate(X))
            activate(n__head(X)) -> head(activate(X))
            activate(n__isLNat(X)) -> isLNat(X)
            activate(n__isNatural(X)) -> isNatural(X)
            activate(n__natsFrom(X)) -> natsFrom(activate(X))
            activate(n__nil()) -> nil()
            activate(n__pair(X1,X2)) -> pair(activate(X1),activate(X2))
            activate(n__s(X)) -> s(activate(X))
            activate(n__sel(X1,X2)) -> sel(activate(X1),activate(X2))
            activate(n__snd(X)) -> snd(activate(X))
            activate(n__splitAt(X1,X2)) -> splitAt(activate(X1),activate(X2))
            activate(n__tail(X)) -> tail(activate(X))
            activate(n__take(X1,X2)) -> take(activate(X1),activate(X2))
            afterNth(N,XS) -> U11(and(isNatural(N),n__isLNat(XS)),N,XS)
            afterNth(X1,X2) -> n__afterNth(X1,X2)
            and(X1,X2) -> n__and(X1,X2)
            and(tt(),X) -> activate(X)
            cons(X1,X2) -> n__cons(X1,X2)
            fst(X) -> n__fst(X)
            fst(pair(X,Y)) -> U21(and(isLNat(X),n__isLNat(Y)),X)
            head(X) -> n__head(X)
            head(cons(N,XS)) -> U31(and(isNatural(N),n__isLNat(activate(XS))),N)
            isLNat(X) -> n__isLNat(X)
            isLNat(n__afterNth(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isLNat(n__cons(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isLNat(n__fst(V1)) -> isPLNat(activate(V1))
            isLNat(n__natsFrom(V1)) -> isNatural(activate(V1))
            isLNat(n__nil()) -> tt()
            isLNat(n__snd(V1)) -> isPLNat(activate(V1))
            isLNat(n__tail(V1)) -> isLNat(activate(V1))
            isLNat(n__take(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isNatural(X) -> n__isNatural(X)
            isNatural(n__0()) -> tt()
            isNatural(n__head(V1)) -> isLNat(activate(V1))
            isNatural(n__s(V1)) -> isNatural(activate(V1))
            isNatural(n__sel(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            isPLNat(n__pair(V1,V2)) -> and(isLNat(activate(V1)),n__isLNat(activate(V2)))
            isPLNat(n__splitAt(V1,V2)) -> and(isNatural(activate(V1)),n__isLNat(activate(V2)))
            natsFrom(N) -> U41(isNatural(N),N)
            natsFrom(X) -> n__natsFrom(X)
            nil() -> n__nil()
            pair(X1,X2) -> n__pair(X1,X2)
            s(X) -> n__s(X)
            sel(N,XS) -> U51(and(isNatural(N),n__isLNat(XS)),N,XS)
            sel(X1,X2) -> n__sel(X1,X2)
            snd(X) -> n__snd(X)
            snd(pair(X,Y)) -> U61(and(isLNat(X),n__isLNat(Y)),Y)
            splitAt(X1,X2) -> n__splitAt(X1,X2)
            splitAt(0(),XS) -> U71(isLNat(XS),XS)
            splitAt(s(N),cons(X,XS)) -> U81(and(isNatural(N),n__and(n__isNatural(X),n__isLNat(activate(XS))))
                                           ,N
                                           ,X
                                           ,activate(XS))
            tail(X) -> n__tail(X)
            tail(cons(N,XS)) -> U91(and(isNatural(N),n__isLNat(activate(XS))),activate(XS))
            take(N,XS) -> U101(and(isNatural(N),n__isLNat(XS)),N,XS)
            take(X1,X2) -> n__take(X1,X2)
        - Signature:
            {0/0,U101/3,U11/3,U21/2,U31/2,U41/2,U51/3,U61/2,U71/2,U81/4,U82/2,U91/2,activate/1,afterNth/2,and/2,cons/2
            ,fst/1,head/1,isLNat/1,isNatural/1,isPLNat/1,natsFrom/1,nil/0,pair/2,s/1,sel/2,snd/1,splitAt/2,tail/1
            ,take/2} / {n__0/0,n__afterNth/2,n__and/2,n__cons/2,n__fst/1,n__head/1,n__isLNat/1,n__isNatural/1
            ,n__natsFrom/1,n__nil/0,n__pair/2,n__s/1,n__sel/2,n__snd/1,n__splitAt/2,n__tail/1,n__take/2,tt/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {0,U101,U11,U21,U31,U41,U51,U61,U71,U81,U82,U91,activate
            ,afterNth,and,cons,fst,head,isLNat,isNatural,isPLNat,natsFrom,nil,pair,s,sel,snd,splitAt,tail
            ,take} and constructors {n__0,n__afterNth,n__and,n__cons,n__fst,n__head,n__isLNat,n__isNatural,n__natsFrom
            ,n__nil,n__pair,n__s,n__sel,n__snd,n__splitAt,n__tail,n__take,tt}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          activate(x){x -> n__afterNth(x,y)} =
            activate(n__afterNth(x,y)) ->^+ afterNth(activate(x),activate(y))
              = C[activate(x) = activate(x){}]

WORST_CASE(Omega(n^1),?)