* Step 1: Sum WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            0() -> n__0()
            U101(tt(),V1,V2) -> U102(isNatural(activate(V1)),activate(V2))
            U102(tt(),V2) -> U103(isLNat(activate(V2)))
            U103(tt()) -> tt()
            U11(tt(),N,XS) -> snd(splitAt(activate(N),activate(XS)))
            U111(tt(),V1) -> U112(isLNat(activate(V1)))
            U112(tt()) -> tt()
            U121(tt(),V1) -> U122(isNatural(activate(V1)))
            U122(tt()) -> tt()
            U131(tt(),V1,V2) -> U132(isNatural(activate(V1)),activate(V2))
            U132(tt(),V2) -> U133(isLNat(activate(V2)))
            U133(tt()) -> tt()
            U141(tt(),V1,V2) -> U142(isLNat(activate(V1)),activate(V2))
            U142(tt(),V2) -> U143(isLNat(activate(V2)))
            U143(tt()) -> tt()
            U151(tt(),V1,V2) -> U152(isNatural(activate(V1)),activate(V2))
            U152(tt(),V2) -> U153(isLNat(activate(V2)))
            U153(tt()) -> tt()
            U161(tt(),N) -> cons(activate(N),n__natsFrom(n__s(activate(N))))
            U171(tt(),N,XS) -> head(afterNth(activate(N),activate(XS)))
            U181(tt(),Y) -> activate(Y)
            U191(tt(),XS) -> pair(nil(),activate(XS))
            U201(tt(),N,X,XS) -> U202(splitAt(activate(N),activate(XS)),activate(X))
            U202(pair(YS,ZS),X) -> pair(cons(activate(X),YS),ZS)
            U21(tt(),X) -> activate(X)
            U211(tt(),XS) -> activate(XS)
            U221(tt(),N,XS) -> fst(splitAt(activate(N),activate(XS)))
            U31(tt(),N) -> activate(N)
            U41(tt(),V1,V2) -> U42(isNatural(activate(V1)),activate(V2))
            U42(tt(),V2) -> U43(isLNat(activate(V2)))
            U43(tt()) -> tt()
            U51(tt(),V1,V2) -> U52(isNatural(activate(V1)),activate(V2))
            U52(tt(),V2) -> U53(isLNat(activate(V2)))
            U53(tt()) -> tt()
            U61(tt(),V1) -> U62(isPLNat(activate(V1)))
            U62(tt()) -> tt()
            U71(tt(),V1) -> U72(isNatural(activate(V1)))
            U72(tt()) -> tt()
            U81(tt(),V1) -> U82(isPLNat(activate(V1)))
            U82(tt()) -> tt()
            U91(tt(),V1) -> U92(isLNat(activate(V1)))
            U92(tt()) -> tt()
            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__isLNatKind(X)) -> isLNatKind(X)
            activate(n__isNatural(X)) -> isNatural(X)
            activate(n__isNaturalKind(X)) -> isNaturalKind(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(and(isNatural(N),n__isNaturalKind(N)),n__and(n__isLNat(XS),n__isLNatKind(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(and(isLNat(X),n__isLNatKind(X)),n__and(n__isLNat(Y),n__isLNatKind(Y))),X)
            head(X) -> n__head(X)
            head(cons(N,XS)) -> U31(and(and(isNatural(N),n__isNaturalKind(N))
                                       ,n__and(n__isLNat(activate(XS)),n__isLNatKind(activate(XS))))
                                   ,N)
            isLNat(X) -> n__isLNat(X)
            isLNat(n__afterNth(V1,V2)) -> U41(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                             ,activate(V1)
                                             ,activate(V2))
            isLNat(n__cons(V1,V2)) -> U51(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                         ,activate(V1)
                                         ,activate(V2))
            isLNat(n__fst(V1)) -> U61(isPLNatKind(activate(V1)),activate(V1))
            isLNat(n__natsFrom(V1)) -> U71(isNaturalKind(activate(V1)),activate(V1))
            isLNat(n__nil()) -> tt()
            isLNat(n__snd(V1)) -> U81(isPLNatKind(activate(V1)),activate(V1))
            isLNat(n__tail(V1)) -> U91(isLNatKind(activate(V1)),activate(V1))
            isLNat(n__take(V1,V2)) -> U101(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                          ,activate(V1)
                                          ,activate(V2))
            isLNatKind(X) -> n__isLNatKind(X)
            isLNatKind(n__afterNth(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isLNatKind(n__cons(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isLNatKind(n__fst(V1)) -> isPLNatKind(activate(V1))
            isLNatKind(n__natsFrom(V1)) -> isNaturalKind(activate(V1))
            isLNatKind(n__nil()) -> tt()
            isLNatKind(n__snd(V1)) -> isPLNatKind(activate(V1))
            isLNatKind(n__tail(V1)) -> isLNatKind(activate(V1))
            isLNatKind(n__take(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isNatural(X) -> n__isNatural(X)
            isNatural(n__0()) -> tt()
            isNatural(n__head(V1)) -> U111(isLNatKind(activate(V1)),activate(V1))
            isNatural(n__s(V1)) -> U121(isNaturalKind(activate(V1)),activate(V1))
            isNatural(n__sel(V1,V2)) -> U131(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                            ,activate(V1)
                                            ,activate(V2))
            isNaturalKind(X) -> n__isNaturalKind(X)
            isNaturalKind(n__0()) -> tt()
            isNaturalKind(n__head(V1)) -> isLNatKind(activate(V1))
            isNaturalKind(n__s(V1)) -> isNaturalKind(activate(V1))
            isNaturalKind(n__sel(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isPLNat(n__pair(V1,V2)) -> U141(and(isLNatKind(activate(V1)),n__isLNatKind(activate(V2)))
                                           ,activate(V1)
                                           ,activate(V2))
            isPLNat(n__splitAt(V1,V2)) -> U151(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                              ,activate(V1)
                                              ,activate(V2))
            isPLNatKind(n__pair(V1,V2)) -> and(isLNatKind(activate(V1)),n__isLNatKind(activate(V2)))
            isPLNatKind(n__splitAt(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            natsFrom(N) -> U161(and(isNatural(N),n__isNaturalKind(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) -> U171(and(and(isNatural(N),n__isNaturalKind(N)),n__and(n__isLNat(XS),n__isLNatKind(XS))),N,XS)
            sel(X1,X2) -> n__sel(X1,X2)
            snd(X) -> n__snd(X)
            snd(pair(X,Y)) -> U181(and(and(isLNat(X),n__isLNatKind(X)),n__and(n__isLNat(Y),n__isLNatKind(Y))),Y)
            splitAt(X1,X2) -> n__splitAt(X1,X2)
            splitAt(0(),XS) -> U191(and(isLNat(XS),n__isLNatKind(XS)),XS)
            splitAt(s(N),cons(X,XS)) -> U201(and(and(isNatural(N),n__isNaturalKind(N))
                                                ,n__and(n__and(n__isNatural(X),n__isNaturalKind(X))
                                                       ,n__and(n__isLNat(activate(XS)),n__isLNatKind(activate(XS)))))
                                            ,N
                                            ,X
                                            ,activate(XS))
            tail(X) -> n__tail(X)
            tail(cons(N,XS)) -> U211(and(and(isNatural(N),n__isNaturalKind(N))
                                        ,n__and(n__isLNat(activate(XS)),n__isLNatKind(activate(XS))))
                                    ,activate(XS))
            take(N,XS) -> U221(and(and(isNatural(N),n__isNaturalKind(N)),n__and(n__isLNat(XS),n__isLNatKind(XS))),N,XS)
            take(X1,X2) -> n__take(X1,X2)
        - Signature:
            {0/0,U101/3,U102/2,U103/1,U11/3,U111/2,U112/1,U121/2,U122/1,U131/3,U132/2,U133/1,U141/3,U142/2,U143/1,U151/3
            ,U152/2,U153/1,U161/2,U171/3,U181/2,U191/2,U201/4,U202/2,U21/2,U211/2,U221/3,U31/2,U41/3,U42/2,U43/1,U51/3
            ,U52/2,U53/1,U61/2,U62/1,U71/2,U72/1,U81/2,U82/1,U91/2,U92/1,activate/1,afterNth/2,and/2,cons/2,fst/1,head/1
            ,isLNat/1,isLNatKind/1,isNatural/1,isNaturalKind/1,isPLNat/1,isPLNatKind/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__isLNatKind/1,n__isNatural/1,n__isNaturalKind/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,U102,U103,U11,U111,U112,U121,U122,U131,U132,U133
            ,U141,U142,U143,U151,U152,U153,U161,U171,U181,U191,U201,U202,U21,U211,U221,U31,U41,U42,U43,U51,U52,U53,U61
            ,U62,U71,U72,U81,U82,U91,U92,activate,afterNth,and,cons,fst,head,isLNat,isLNatKind,isNatural,isNaturalKind
            ,isPLNat,isPLNatKind,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__isLNatKind,n__isNatural,n__isNaturalKind,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(),V1,V2) -> U102(isNatural(activate(V1)),activate(V2))
            U102(tt(),V2) -> U103(isLNat(activate(V2)))
            U103(tt()) -> tt()
            U11(tt(),N,XS) -> snd(splitAt(activate(N),activate(XS)))
            U111(tt(),V1) -> U112(isLNat(activate(V1)))
            U112(tt()) -> tt()
            U121(tt(),V1) -> U122(isNatural(activate(V1)))
            U122(tt()) -> tt()
            U131(tt(),V1,V2) -> U132(isNatural(activate(V1)),activate(V2))
            U132(tt(),V2) -> U133(isLNat(activate(V2)))
            U133(tt()) -> tt()
            U141(tt(),V1,V2) -> U142(isLNat(activate(V1)),activate(V2))
            U142(tt(),V2) -> U143(isLNat(activate(V2)))
            U143(tt()) -> tt()
            U151(tt(),V1,V2) -> U152(isNatural(activate(V1)),activate(V2))
            U152(tt(),V2) -> U153(isLNat(activate(V2)))
            U153(tt()) -> tt()
            U161(tt(),N) -> cons(activate(N),n__natsFrom(n__s(activate(N))))
            U171(tt(),N,XS) -> head(afterNth(activate(N),activate(XS)))
            U181(tt(),Y) -> activate(Y)
            U191(tt(),XS) -> pair(nil(),activate(XS))
            U201(tt(),N,X,XS) -> U202(splitAt(activate(N),activate(XS)),activate(X))
            U202(pair(YS,ZS),X) -> pair(cons(activate(X),YS),ZS)
            U21(tt(),X) -> activate(X)
            U211(tt(),XS) -> activate(XS)
            U221(tt(),N,XS) -> fst(splitAt(activate(N),activate(XS)))
            U31(tt(),N) -> activate(N)
            U41(tt(),V1,V2) -> U42(isNatural(activate(V1)),activate(V2))
            U42(tt(),V2) -> U43(isLNat(activate(V2)))
            U43(tt()) -> tt()
            U51(tt(),V1,V2) -> U52(isNatural(activate(V1)),activate(V2))
            U52(tt(),V2) -> U53(isLNat(activate(V2)))
            U53(tt()) -> tt()
            U61(tt(),V1) -> U62(isPLNat(activate(V1)))
            U62(tt()) -> tt()
            U71(tt(),V1) -> U72(isNatural(activate(V1)))
            U72(tt()) -> tt()
            U81(tt(),V1) -> U82(isPLNat(activate(V1)))
            U82(tt()) -> tt()
            U91(tt(),V1) -> U92(isLNat(activate(V1)))
            U92(tt()) -> tt()
            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__isLNatKind(X)) -> isLNatKind(X)
            activate(n__isNatural(X)) -> isNatural(X)
            activate(n__isNaturalKind(X)) -> isNaturalKind(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(and(isNatural(N),n__isNaturalKind(N)),n__and(n__isLNat(XS),n__isLNatKind(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(and(isLNat(X),n__isLNatKind(X)),n__and(n__isLNat(Y),n__isLNatKind(Y))),X)
            head(X) -> n__head(X)
            head(cons(N,XS)) -> U31(and(and(isNatural(N),n__isNaturalKind(N))
                                       ,n__and(n__isLNat(activate(XS)),n__isLNatKind(activate(XS))))
                                   ,N)
            isLNat(X) -> n__isLNat(X)
            isLNat(n__afterNth(V1,V2)) -> U41(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                             ,activate(V1)
                                             ,activate(V2))
            isLNat(n__cons(V1,V2)) -> U51(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                         ,activate(V1)
                                         ,activate(V2))
            isLNat(n__fst(V1)) -> U61(isPLNatKind(activate(V1)),activate(V1))
            isLNat(n__natsFrom(V1)) -> U71(isNaturalKind(activate(V1)),activate(V1))
            isLNat(n__nil()) -> tt()
            isLNat(n__snd(V1)) -> U81(isPLNatKind(activate(V1)),activate(V1))
            isLNat(n__tail(V1)) -> U91(isLNatKind(activate(V1)),activate(V1))
            isLNat(n__take(V1,V2)) -> U101(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                          ,activate(V1)
                                          ,activate(V2))
            isLNatKind(X) -> n__isLNatKind(X)
            isLNatKind(n__afterNth(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isLNatKind(n__cons(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isLNatKind(n__fst(V1)) -> isPLNatKind(activate(V1))
            isLNatKind(n__natsFrom(V1)) -> isNaturalKind(activate(V1))
            isLNatKind(n__nil()) -> tt()
            isLNatKind(n__snd(V1)) -> isPLNatKind(activate(V1))
            isLNatKind(n__tail(V1)) -> isLNatKind(activate(V1))
            isLNatKind(n__take(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isNatural(X) -> n__isNatural(X)
            isNatural(n__0()) -> tt()
            isNatural(n__head(V1)) -> U111(isLNatKind(activate(V1)),activate(V1))
            isNatural(n__s(V1)) -> U121(isNaturalKind(activate(V1)),activate(V1))
            isNatural(n__sel(V1,V2)) -> U131(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                            ,activate(V1)
                                            ,activate(V2))
            isNaturalKind(X) -> n__isNaturalKind(X)
            isNaturalKind(n__0()) -> tt()
            isNaturalKind(n__head(V1)) -> isLNatKind(activate(V1))
            isNaturalKind(n__s(V1)) -> isNaturalKind(activate(V1))
            isNaturalKind(n__sel(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            isPLNat(n__pair(V1,V2)) -> U141(and(isLNatKind(activate(V1)),n__isLNatKind(activate(V2)))
                                           ,activate(V1)
                                           ,activate(V2))
            isPLNat(n__splitAt(V1,V2)) -> U151(and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
                                              ,activate(V1)
                                              ,activate(V2))
            isPLNatKind(n__pair(V1,V2)) -> and(isLNatKind(activate(V1)),n__isLNatKind(activate(V2)))
            isPLNatKind(n__splitAt(V1,V2)) -> and(isNaturalKind(activate(V1)),n__isLNatKind(activate(V2)))
            natsFrom(N) -> U161(and(isNatural(N),n__isNaturalKind(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) -> U171(and(and(isNatural(N),n__isNaturalKind(N)),n__and(n__isLNat(XS),n__isLNatKind(XS))),N,XS)
            sel(X1,X2) -> n__sel(X1,X2)
            snd(X) -> n__snd(X)
            snd(pair(X,Y)) -> U181(and(and(isLNat(X),n__isLNatKind(X)),n__and(n__isLNat(Y),n__isLNatKind(Y))),Y)
            splitAt(X1,X2) -> n__splitAt(X1,X2)
            splitAt(0(),XS) -> U191(and(isLNat(XS),n__isLNatKind(XS)),XS)
            splitAt(s(N),cons(X,XS)) -> U201(and(and(isNatural(N),n__isNaturalKind(N))
                                                ,n__and(n__and(n__isNatural(X),n__isNaturalKind(X))
                                                       ,n__and(n__isLNat(activate(XS)),n__isLNatKind(activate(XS)))))
                                            ,N
                                            ,X
                                            ,activate(XS))
            tail(X) -> n__tail(X)
            tail(cons(N,XS)) -> U211(and(and(isNatural(N),n__isNaturalKind(N))
                                        ,n__and(n__isLNat(activate(XS)),n__isLNatKind(activate(XS))))
                                    ,activate(XS))
            take(N,XS) -> U221(and(and(isNatural(N),n__isNaturalKind(N)),n__and(n__isLNat(XS),n__isLNatKind(XS))),N,XS)
            take(X1,X2) -> n__take(X1,X2)
        - Signature:
            {0/0,U101/3,U102/2,U103/1,U11/3,U111/2,U112/1,U121/2,U122/1,U131/3,U132/2,U133/1,U141/3,U142/2,U143/1,U151/3
            ,U152/2,U153/1,U161/2,U171/3,U181/2,U191/2,U201/4,U202/2,U21/2,U211/2,U221/3,U31/2,U41/3,U42/2,U43/1,U51/3
            ,U52/2,U53/1,U61/2,U62/1,U71/2,U72/1,U81/2,U82/1,U91/2,U92/1,activate/1,afterNth/2,and/2,cons/2,fst/1,head/1
            ,isLNat/1,isLNatKind/1,isNatural/1,isNaturalKind/1,isPLNat/1,isPLNatKind/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__isLNatKind/1,n__isNatural/1,n__isNaturalKind/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,U102,U103,U11,U111,U112,U121,U122,U131,U132,U133
            ,U141,U142,U143,U151,U152,U153,U161,U171,U181,U191,U201,U202,U21,U211,U221,U31,U41,U42,U43,U51,U52,U53,U61
            ,U62,U71,U72,U81,U82,U91,U92,activate,afterNth,and,cons,fst,head,isLNat,isLNatKind,isNatural,isNaturalKind
            ,isPLNat,isPLNatKind,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__isLNatKind,n__isNatural,n__isNaturalKind,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),?)