MAYBE
Time: 0.004775
TRS:
 {                 cons(X1, X2) -> n__cons(X1, X2),
                        oddNs() -> incr pairNs(),
                       pairNs() -> cons(0(), n__incr oddNs()),
                         incr X -> n__incr X,
               incr cons(X, XS) -> cons(s X, n__incr activate XS),
                     activate X -> X,
             activate n__incr X -> incr X,
       activate n__take(X1, X2) -> take(X1, X2),
        activate n__zip(X1, X2) -> zip(X1, X2),
       activate n__cons(X1, X2) -> cons(X1, X2),
         activate n__repItems X -> repItems 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:
  DP:
   {                      oddNs#() -> pairNs#(),
                          oddNs#() -> incr# pairNs(),
                         pairNs#() -> cons#(0(), n__incr oddNs()),
                         pairNs#() -> oddNs#(),
                 incr# cons(X, XS) -> cons#(s X, n__incr activate XS),
                 incr# cons(X, XS) -> activate# XS,
               activate# n__incr X -> incr# X,
         activate# n__take(X1, X2) -> take#(X1, X2),
          activate# n__zip(X1, X2) -> zip#(X1, X2),
         activate# n__cons(X1, X2) -> cons#(X1, X2),
           activate# n__repItems X -> repItems# 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}
  TRS:
  {                 cons(X1, X2) -> n__cons(X1, X2),
                         oddNs() -> incr pairNs(),
                        pairNs() -> cons(0(), n__incr oddNs()),
                          incr X -> n__incr X,
                incr cons(X, XS) -> cons(s X, n__incr activate XS),
                      activate X -> X,
              activate n__incr X -> incr X,
        activate n__take(X1, X2) -> take(X1, X2),
         activate n__zip(X1, X2) -> zip(X1, X2),
        activate n__cons(X1, X2) -> cons(X1, X2),
          activate n__repItems X -> repItems 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()}
  UR:
   {                 cons(X1, X2) -> n__cons(X1, X2),
                          oddNs() -> incr pairNs(),
                         pairNs() -> cons(0(), n__incr oddNs()),
                           incr X -> n__incr X,
                 incr cons(X, XS) -> cons(s X, n__incr activate XS),
                       activate X -> X,
               activate n__incr X -> incr X,
         activate n__take(X1, X2) -> take(X1, X2),
          activate n__zip(X1, X2) -> zip(X1, X2),
         activate n__cons(X1, X2) -> cons(X1, X2),
           activate n__repItems X -> repItems 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(),
                       repItems X -> n__repItems X,
             repItems cons(X, XS) -> cons(X, n__cons(X, n__repItems activate XS)),
                   repItems nil() -> nil(),
                          a(x, y) -> x,
                          a(x, y) -> y}
   EDG:
    {(activate# n__zip(X1, X2) -> zip#(X1, X2), zip#(cons(X, XS), cons(Y, YS)) -> activate# YS)
     (activate# n__zip(X1, X2) -> zip#(X1, X2), zip#(cons(X, XS), cons(Y, YS)) -> activate# XS)
     (activate# n__zip(X1, X2) -> zip#(X1, X2), zip#(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), n__zip(activate XS, activate YS)))
     (activate# n__incr X -> incr# X, incr# cons(X, XS) -> activate# XS)
     (activate# n__incr X -> incr# X, incr# cons(X, XS) -> cons#(s X, n__incr activate XS))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# YS, activate# n__repItems X -> repItems# X)
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# YS, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# YS, activate# n__zip(X1, X2) -> zip#(X1, X2))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# YS, activate# n__take(X1, X2) -> take#(X1, X2))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# YS, activate# n__incr X -> incr# X)
     (pairNs#() -> oddNs#(), oddNs#() -> incr# pairNs())
     (pairNs#() -> oddNs#(), oddNs#() -> pairNs#())
     (take#(s N, cons(X, XS)) -> activate# XS, activate# n__repItems X -> repItems# X)
     (take#(s N, cons(X, XS)) -> activate# XS, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (take#(s N, cons(X, XS)) -> activate# XS, activate# n__zip(X1, X2) -> zip#(X1, X2))
     (take#(s N, cons(X, XS)) -> activate# XS, activate# n__take(X1, X2) -> take#(X1, X2))
     (take#(s N, cons(X, XS)) -> activate# XS, activate# n__incr X -> incr# X)
     (tail# cons(X, XS) -> activate# XS, activate# n__repItems X -> repItems# X)
     (tail# cons(X, XS) -> activate# XS, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (tail# cons(X, XS) -> activate# XS, activate# n__zip(X1, X2) -> zip#(X1, X2))
     (tail# cons(X, XS) -> activate# XS, activate# n__take(X1, X2) -> take#(X1, X2))
     (tail# cons(X, XS) -> activate# XS, activate# n__incr X -> incr# X)
     (repItems# cons(X, XS) -> activate# XS, activate# n__incr X -> incr# X)
     (repItems# cons(X, XS) -> activate# XS, activate# n__take(X1, X2) -> take#(X1, X2))
     (repItems# cons(X, XS) -> activate# XS, activate# n__zip(X1, X2) -> zip#(X1, X2))
     (repItems# cons(X, XS) -> activate# XS, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (repItems# cons(X, XS) -> activate# XS, activate# n__repItems X -> repItems# X)
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# XS, activate# n__incr X -> incr# X)
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# XS, activate# n__take(X1, X2) -> take#(X1, X2))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# XS, activate# n__zip(X1, X2) -> zip#(X1, X2))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# XS, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (zip#(cons(X, XS), cons(Y, YS)) -> activate# XS, activate# n__repItems X -> repItems# X)
     (incr# cons(X, XS) -> activate# XS, activate# n__incr X -> incr# X)
     (incr# cons(X, XS) -> activate# XS, activate# n__take(X1, X2) -> take#(X1, X2))
     (incr# cons(X, XS) -> activate# XS, activate# n__zip(X1, X2) -> zip#(X1, X2))
     (incr# cons(X, XS) -> activate# XS, activate# n__cons(X1, X2) -> cons#(X1, X2))
     (incr# cons(X, XS) -> activate# XS, activate# n__repItems X -> repItems# X)
     (oddNs#() -> pairNs#(), pairNs#() -> cons#(0(), n__incr oddNs()))
     (oddNs#() -> pairNs#(), pairNs#() -> oddNs#())
     (activate# n__repItems X -> repItems# X, repItems# cons(X, XS) -> cons#(X, n__cons(X, n__repItems activate XS)))
     (activate# n__repItems X -> repItems# X, repItems# cons(X, XS) -> activate# XS)
     (activate# n__take(X1, X2) -> take#(X1, X2), take#(s N, cons(X, XS)) -> cons#(X, n__take(N, activate XS)))
     (activate# n__take(X1, X2) -> take#(X1, X2), take#(s N, cons(X, XS)) -> activate# XS)
     (oddNs#() -> incr# pairNs(), incr# cons(X, XS) -> cons#(s X, n__incr activate XS))
     (oddNs#() -> incr# pairNs(), incr# cons(X, XS) -> activate# XS)}
    STATUS:
     arrows: 0.875346
     SCCS (2):
      Scc:
       { oddNs#() -> pairNs#(),
        pairNs#() -> oddNs#()}
      Scc:
       {             incr# cons(X, XS) -> activate# XS,
                   activate# n__incr X -> incr# X,
             activate# n__take(X1, X2) -> take#(X1, X2),
              activate# n__zip(X1, X2) -> zip#(X1, X2),
               activate# n__repItems X -> repItems# 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 (2):
       Strict:
        { oddNs#() -> pairNs#(),
         pairNs#() -> oddNs#()}
       Weak:
       {                 cons(X1, X2) -> n__cons(X1, X2),
                              oddNs() -> incr pairNs(),
                             pairNs() -> cons(0(), n__incr oddNs()),
                               incr X -> n__incr X,
                     incr cons(X, XS) -> cons(s X, n__incr activate XS),
                           activate X -> X,
                   activate n__incr X -> incr X,
             activate n__take(X1, X2) -> take(X1, X2),
              activate n__zip(X1, X2) -> zip(X1, X2),
             activate n__cons(X1, X2) -> cons(X1, X2),
               activate n__repItems X -> repItems 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()}
       Open
      
      
      SCC (9):
       Strict:
        {             incr# cons(X, XS) -> activate# XS,
                    activate# n__incr X -> incr# X,
              activate# n__take(X1, X2) -> take#(X1, X2),
               activate# n__zip(X1, X2) -> zip#(X1, X2),
                activate# n__repItems X -> repItems# 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),
                              oddNs() -> incr pairNs(),
                             pairNs() -> cons(0(), n__incr oddNs()),
                               incr X -> n__incr X,
                     incr cons(X, XS) -> cons(s X, n__incr activate XS),
                           activate X -> X,
                   activate n__incr X -> incr X,
             activate n__take(X1, X2) -> take(X1, X2),
              activate n__zip(X1, X2) -> zip(X1, X2),
             activate n__cons(X1, X2) -> cons(X1, X2),
               activate n__repItems X -> repItems 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()}
       Open