MAYBE
TRS:
 {                 cons(X1, X2) -> n__cons(X1, X2),
                       pairNs() -> cons(0(), n__incr(n__oddNs())),
                        incr(X) -> n__incr(X),
              incr(cons(X, XS)) -> cons(s(X), n__incr(activate(XS))),
                        oddNs() -> n__oddNs(),
                        oddNs() -> incr(pairNs()),
                    activate(X) -> X,
           activate(n__incr(X)) -> incr(activate(X)),
           activate(n__oddNs()) -> oddNs(),
      activate(n__take(X1, X2)) -> take(activate(X1), activate(X2)),
       activate(n__zip(X1, X2)) -> zip(activate(X1), activate(X2)),
      activate(n__cons(X1, X2)) -> cons(activate(X1), X2),
       activate(n__repItems(X)) -> repItems(activate(X)),
                   take(X1, X2) -> n__take(X1, X2),
                  take(0(), XS) -> nil(),
        take(s(N), cons(X, XS)) -> cons(X, n__take(N, activate(XS))),
                  zip(X, nil()) -> nil(),
                    zip(X1, X2) -> n__zip(X1, X2),
  zip(cons(X, XS), cons(Y, YS)) -> cons(pair(X, Y), n__zip(activate(XS), activate(YS))),
                 zip(nil(), XS) -> nil(),
              tail(cons(X, XS)) -> activate(XS),
                    repItems(X) -> n__repItems(X),
          repItems(cons(X, XS)) -> cons(X, n__cons(X, n__repItems(activate(XS)))),
                repItems(nil()) -> nil()}
 DP:
  Strict:
   {                     pairNs#() -> cons#(0(), n__incr(n__oddNs())),
                incr#(cons(X, XS)) -> cons#(s(X), n__incr(activate(XS))),
                incr#(cons(X, XS)) -> activate#(XS),
                          oddNs#() -> pairNs#(),
                          oddNs#() -> incr#(pairNs()),
             activate#(n__incr(X)) -> incr#(activate(X)),
             activate#(n__incr(X)) -> activate#(X),
             activate#(n__oddNs()) -> oddNs#(),
        activate#(n__take(X1, X2)) -> activate#(X1),
        activate#(n__take(X1, X2)) -> activate#(X2),
        activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)),
         activate#(n__zip(X1, X2)) -> activate#(X1),
         activate#(n__zip(X1, X2)) -> activate#(X2),
         activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)),
        activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2),
        activate#(n__cons(X1, X2)) -> activate#(X1),
         activate#(n__repItems(X)) -> activate#(X),
         activate#(n__repItems(X)) -> repItems#(activate(X)),
          take#(s(N), cons(X, XS)) -> cons#(X, n__take(N, activate(XS))),
          take#(s(N), cons(X, XS)) -> activate#(XS),
    zip#(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), n__zip(activate(XS), activate(YS))),
    zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS),
    zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS),
                tail#(cons(X, XS)) -> activate#(XS),
            repItems#(cons(X, XS)) -> cons#(X, n__cons(X, n__repItems(activate(XS)))),
            repItems#(cons(X, XS)) -> activate#(XS)}
  Weak:
  {                 cons(X1, X2) -> n__cons(X1, X2),
                        pairNs() -> cons(0(), n__incr(n__oddNs())),
                         incr(X) -> n__incr(X),
               incr(cons(X, XS)) -> cons(s(X), n__incr(activate(XS))),
                         oddNs() -> n__oddNs(),
                         oddNs() -> incr(pairNs()),
                     activate(X) -> X,
            activate(n__incr(X)) -> incr(activate(X)),
            activate(n__oddNs()) -> oddNs(),
       activate(n__take(X1, X2)) -> take(activate(X1), activate(X2)),
        activate(n__zip(X1, X2)) -> zip(activate(X1), activate(X2)),
       activate(n__cons(X1, X2)) -> cons(activate(X1), X2),
        activate(n__repItems(X)) -> repItems(activate(X)),
                    take(X1, X2) -> n__take(X1, X2),
                   take(0(), XS) -> nil(),
         take(s(N), cons(X, XS)) -> cons(X, n__take(N, activate(XS))),
                   zip(X, nil()) -> nil(),
                     zip(X1, X2) -> n__zip(X1, X2),
   zip(cons(X, XS), cons(Y, YS)) -> cons(pair(X, Y), n__zip(activate(XS), activate(YS))),
                  zip(nil(), XS) -> nil(),
               tail(cons(X, XS)) -> activate(XS),
                     repItems(X) -> n__repItems(X),
           repItems(cons(X, XS)) -> cons(X, n__cons(X, n__repItems(activate(XS)))),
                 repItems(nil()) -> nil()}
  EDG:
   {
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__zip(X1, X2)) -> activate#(X2), activate#(n__incr(X)) -> incr#(activate(X)))
    (oddNs#() -> incr#(pairNs()), incr#(cons(X, XS)) -> activate#(XS))
    (oddNs#() -> incr#(pairNs()), incr#(cons(X, XS)) -> cons#(s(X), n__incr(activate(XS))))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__repItems(X)) -> activate#(X))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> activate#(X1))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X2))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X1))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X2))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X1))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__oddNs()) -> oddNs#())
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__incr(X)) -> activate#(X))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS), activate#(n__incr(X)) -> incr#(activate(X)))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> activate#(X))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> activate#(X1))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X2))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X1))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X2))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X1))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__oddNs()) -> oddNs#())
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> activate#(X))
    (repItems#(cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__take(X1, X2)) -> activate#(X1), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__cons(X1, X2)) -> activate#(X1), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__incr(X)) -> activate#(X), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__incr(X)) -> activate#(X), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)), take#(s(N), cons(X, XS)) -> activate#(XS))
    (activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)), take#(s(N), cons(X, XS)) -> cons#(X, n__take(N, activate(XS))))
    (oddNs#() -> pairNs#(), pairNs#() -> cons#(0(), n__incr(n__oddNs())))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__repItems(X)) -> activate#(X))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__cons(X1, X2)) -> activate#(X1))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__zip(X1, X2)) -> activate#(X2))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__zip(X1, X2)) -> activate#(X1))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__take(X1, X2)) -> activate#(X2))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__take(X1, X2)) -> activate#(X1))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__oddNs()) -> oddNs#())
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__incr(X)) -> activate#(X))
    (zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__repItems(X)) -> repItems#(activate(X)), repItems#(cons(X, XS)) -> activate#(XS))
    (activate#(n__repItems(X)) -> repItems#(activate(X)), repItems#(cons(X, XS)) -> cons#(X, n__cons(X, n__repItems(activate(XS)))))
    (activate#(n__incr(X)) -> incr#(activate(X)), incr#(cons(X, XS)) -> cons#(s(X), n__incr(activate(XS))))
    (activate#(n__incr(X)) -> incr#(activate(X)), incr#(cons(X, XS)) -> activate#(XS))
    (activate#(n__oddNs()) -> oddNs#(), oddNs#() -> pairNs#())
    (activate#(n__oddNs()) -> oddNs#(), oddNs#() -> incr#(pairNs()))
    (activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)), zip#(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), n__zip(activate(XS), activate(YS))))
    (activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)), zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS))
    (activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)), zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__repItems(X)) -> activate#(X), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__zip(X1, X2)) -> activate#(X1), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> incr#(activate(X)))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> activate#(X))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__oddNs()) -> oddNs#())
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X1))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X2))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X1))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X2))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> activate#(X1))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> activate#(X))
    (tail#(cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> incr#(activate(X)))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> activate#(X))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__oddNs()) -> oddNs#())
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X1))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X2))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X1))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X2))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> activate#(X1))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> activate#(X))
    (take#(s(N), cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> incr#(activate(X)))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__incr(X)) -> activate#(X))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__oddNs()) -> oddNs#())
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X1))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> activate#(X2))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X1))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> activate#(X2))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__cons(X1, X2)) -> activate#(X1))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> activate#(X))
    (incr#(cons(X, XS)) -> activate#(XS), activate#(n__repItems(X)) -> repItems#(activate(X)))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__incr(X)) -> incr#(activate(X)))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__incr(X)) -> activate#(X))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__oddNs()) -> oddNs#())
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__take(X1, X2)) -> activate#(X1))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__take(X1, X2)) -> activate#(X2))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__zip(X1, X2)) -> activate#(X1))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__zip(X1, X2)) -> activate#(X2))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__cons(X1, X2)) -> cons#(activate(X1), X2))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__cons(X1, X2)) -> activate#(X1))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__repItems(X)) -> activate#(X))
    (activate#(n__take(X1, X2)) -> activate#(X2), activate#(n__repItems(X)) -> repItems#(activate(X)))
   }
   SCCS:
    Scc:
     {            incr#(cons(X, XS)) -> activate#(XS),
                            oddNs#() -> incr#(pairNs()),
               activate#(n__incr(X)) -> incr#(activate(X)),
               activate#(n__incr(X)) -> activate#(X),
               activate#(n__oddNs()) -> oddNs#(),
          activate#(n__take(X1, X2)) -> activate#(X1),
          activate#(n__take(X1, X2)) -> activate#(X2),
          activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)),
           activate#(n__zip(X1, X2)) -> activate#(X1),
           activate#(n__zip(X1, X2)) -> activate#(X2),
           activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)),
          activate#(n__cons(X1, X2)) -> activate#(X1),
           activate#(n__repItems(X)) -> activate#(X),
           activate#(n__repItems(X)) -> repItems#(activate(X)),
            take#(s(N), cons(X, XS)) -> activate#(XS),
      zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS),
      zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS),
              repItems#(cons(X, XS)) -> activate#(XS)}
    SCC:
     Strict:
      {            incr#(cons(X, XS)) -> activate#(XS),
                             oddNs#() -> incr#(pairNs()),
                activate#(n__incr(X)) -> incr#(activate(X)),
                activate#(n__incr(X)) -> activate#(X),
                activate#(n__oddNs()) -> oddNs#(),
           activate#(n__take(X1, X2)) -> activate#(X1),
           activate#(n__take(X1, X2)) -> activate#(X2),
           activate#(n__take(X1, X2)) -> take#(activate(X1), activate(X2)),
            activate#(n__zip(X1, X2)) -> activate#(X1),
            activate#(n__zip(X1, X2)) -> activate#(X2),
            activate#(n__zip(X1, X2)) -> zip#(activate(X1), activate(X2)),
           activate#(n__cons(X1, X2)) -> activate#(X1),
            activate#(n__repItems(X)) -> activate#(X),
            activate#(n__repItems(X)) -> repItems#(activate(X)),
             take#(s(N), cons(X, XS)) -> activate#(XS),
       zip#(cons(X, XS), cons(Y, YS)) -> activate#(XS),
       zip#(cons(X, XS), cons(Y, YS)) -> activate#(YS),
               repItems#(cons(X, XS)) -> activate#(XS)}
     Weak:
     {                 cons(X1, X2) -> n__cons(X1, X2),
                           pairNs() -> cons(0(), n__incr(n__oddNs())),
                            incr(X) -> n__incr(X),
                  incr(cons(X, XS)) -> cons(s(X), n__incr(activate(XS))),
                            oddNs() -> n__oddNs(),
                            oddNs() -> incr(pairNs()),
                        activate(X) -> X,
               activate(n__incr(X)) -> incr(activate(X)),
               activate(n__oddNs()) -> oddNs(),
          activate(n__take(X1, X2)) -> take(activate(X1), activate(X2)),
           activate(n__zip(X1, X2)) -> zip(activate(X1), activate(X2)),
          activate(n__cons(X1, X2)) -> cons(activate(X1), X2),
           activate(n__repItems(X)) -> repItems(activate(X)),
                       take(X1, X2) -> n__take(X1, X2),
                      take(0(), XS) -> nil(),
            take(s(N), cons(X, XS)) -> cons(X, n__take(N, activate(XS))),
                      zip(X, nil()) -> nil(),
                        zip(X1, X2) -> n__zip(X1, X2),
      zip(cons(X, XS), cons(Y, YS)) -> cons(pair(X, Y), n__zip(activate(XS), activate(YS))),
                     zip(nil(), XS) -> nil(),
                  tail(cons(X, XS)) -> activate(XS),
                        repItems(X) -> n__repItems(X),
              repItems(cons(X, XS)) -> cons(X, n__cons(X, n__repItems(activate(XS)))),
                    repItems(nil()) -> nil()}
     Fail