MAYBE
* Step 1: Failure MAYBE
  + 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(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(X1,X2)
          activate(n__and(X1,X2)) -> and(X1,X2)
          activate(n__cons(X1,X2)) -> cons(X1,X2)
          activate(n__fst(X)) -> fst(X)
          activate(n__head(X)) -> head(X)
          activate(n__isLNat(X)) -> isLNat(X)
          activate(n__natsFrom(X)) -> natsFrom(X)
          activate(n__nil()) -> nil()
          activate(n__pair(X1,X2)) -> pair(X1,X2)
          activate(n__s(X)) -> s(X)
          activate(n__sel(X1,X2)) -> sel(X1,X2)
          activate(n__snd(X)) -> snd(X)
          activate(n__splitAt(X1,X2)) -> splitAt(X1,X2)
          activate(n__tail(X)) -> tail(X)
          activate(n__take(X1,X2)) -> take(X1,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(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(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__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__natsFrom,n__nil,n__pair
          ,n__s,n__sel,n__snd,n__splitAt,n__tail,n__take,tt}
  + Applied Processor:
      NaturalMI {miDimension = 3, miDegree = 3, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
  + Details:
      Incompatible
MAYBE