MAYBE
MAYBE
TRS:
 {
                     mark(cons(X1, X2)) -> active(cons(mark(X1), X2)),
                              mark(0()) -> active(0()),
                          mark(incr(X)) -> active(incr(mark(X))),
                          mark(oddNs()) -> active(oddNs()),
                         mark(pairNs()) -> active(pairNs()),
                             mark(s(X)) -> active(s(mark(X))),
                            mark(nil()) -> active(nil()),
                     mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))),
                      mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))),
                     mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))),
                          mark(tail(X)) -> active(tail(mark(X))),
                      mark(repItems(X)) -> active(repItems(mark(X))),
                     cons(X1, mark(X2)) -> cons(X1, X2),
                   cons(X1, active(X2)) -> cons(X1, X2),
                     cons(mark(X1), X2) -> cons(X1, X2),
                   cons(active(X1), X2) -> cons(X1, X2),
                          incr(mark(X)) -> incr(X),
                        incr(active(X)) -> incr(X),
              active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))),
                        active(oddNs()) -> mark(incr(pairNs())),
                       active(pairNs()) -> mark(cons(0(), incr(oddNs()))),
                  active(take(0(), XS)) -> mark(nil()),
        active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))),
                  active(zip(X, nil())) -> mark(nil()),
  active(zip(cons(X, XS), cons(Y, YS))) ->
  mark(cons(pair(X, Y), zip(XS, YS))),
                 active(zip(nil(), XS)) -> mark(nil()),
              active(tail(cons(X, XS))) -> mark(XS),
          active(repItems(cons(X, XS))) ->
  mark(cons(X, cons(X, repItems(XS)))),
                active(repItems(nil())) -> mark(nil()),
                             s(mark(X)) -> s(X),
                           s(active(X)) -> s(X),
                     take(X1, mark(X2)) -> take(X1, X2),
                   take(X1, active(X2)) -> take(X1, X2),
                     take(mark(X1), X2) -> take(X1, X2),
                   take(active(X1), X2) -> take(X1, X2),
                      zip(X1, mark(X2)) -> zip(X1, X2),
                    zip(X1, active(X2)) -> zip(X1, X2),
                      zip(mark(X1), X2) -> zip(X1, X2),
                    zip(active(X1), X2) -> zip(X1, X2),
                     pair(X1, mark(X2)) -> pair(X1, X2),
                   pair(X1, active(X2)) -> pair(X1, X2),
                     pair(mark(X1), X2) -> pair(X1, X2),
                   pair(active(X1), X2) -> pair(X1, X2),
                          tail(mark(X)) -> tail(X),
                        tail(active(X)) -> tail(X),
                      repItems(mark(X)) -> repItems(X),
                    repItems(active(X)) -> repItems(X)
 }
 DUP: We consider a duplicating system.
  Trs:
   {
                       mark(cons(X1, X2)) -> active(cons(mark(X1), X2)),
                                mark(0()) -> active(0()),
                            mark(incr(X)) -> active(incr(mark(X))),
                            mark(oddNs()) -> active(oddNs()),
                           mark(pairNs()) -> active(pairNs()),
                               mark(s(X)) -> active(s(mark(X))),
                              mark(nil()) -> active(nil()),
                       mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))),
                        mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))),
                       mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))),
                            mark(tail(X)) -> active(tail(mark(X))),
                        mark(repItems(X)) -> active(repItems(mark(X))),
                       cons(X1, mark(X2)) -> cons(X1, X2),
                     cons(X1, active(X2)) -> cons(X1, X2),
                       cons(mark(X1), X2) -> cons(X1, X2),
                     cons(active(X1), X2) -> cons(X1, X2),
                            incr(mark(X)) -> incr(X),
                          incr(active(X)) -> incr(X),
                active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))),
                          active(oddNs()) -> mark(incr(pairNs())),
                         active(pairNs()) -> mark(cons(0(), incr(oddNs()))),
                    active(take(0(), XS)) -> mark(nil()),
          active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))),
                    active(zip(X, nil())) -> mark(nil()),
    active(zip(cons(X, XS), cons(Y, YS))) ->
    mark(cons(pair(X, Y), zip(XS, YS))),
                   active(zip(nil(), XS)) -> mark(nil()),
                active(tail(cons(X, XS))) -> mark(XS),
            active(repItems(cons(X, XS))) ->
    mark(cons(X, cons(X, repItems(XS)))),
                  active(repItems(nil())) -> mark(nil()),
                               s(mark(X)) -> s(X),
                             s(active(X)) -> s(X),
                       take(X1, mark(X2)) -> take(X1, X2),
                     take(X1, active(X2)) -> take(X1, X2),
                       take(mark(X1), X2) -> take(X1, X2),
                     take(active(X1), X2) -> take(X1, X2),
                        zip(X1, mark(X2)) -> zip(X1, X2),
                      zip(X1, active(X2)) -> zip(X1, X2),
                        zip(mark(X1), X2) -> zip(X1, X2),
                      zip(active(X1), X2) -> zip(X1, X2),
                       pair(X1, mark(X2)) -> pair(X1, X2),
                     pair(X1, active(X2)) -> pair(X1, X2),
                       pair(mark(X1), X2) -> pair(X1, X2),
                     pair(active(X1), X2) -> pair(X1, X2),
                            tail(mark(X)) -> tail(X),
                          tail(active(X)) -> tail(X),
                        repItems(mark(X)) -> repItems(X),
                      repItems(active(X)) -> repItems(X)
   }
  Fail