MAYBE
MAYBE
TRS:
 {
                     cons(mark(X1), X2) -> mark(cons(X1, X2)),
                   cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)),
                          incr(mark(X)) -> mark(incr(X)),
                            incr(ok(X)) -> ok(incr(X)),
                   active(cons(X1, X2)) -> cons(active(X1), X2),
                        active(incr(X)) -> incr(active(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(s(X)) -> s(active(X)),
                   active(take(X1, X2)) -> take(X1, active(X2)),
                   active(take(X1, X2)) -> take(active(X1), X2),
                  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(X1, X2)) -> zip(X1, active(X2)),
                    active(zip(X1, X2)) -> zip(active(X1), X2),
  active(zip(cons(X, XS), cons(Y, YS))) ->
  mark(cons(pair(X, Y), zip(XS, YS))),
                 active(zip(nil(), XS)) -> mark(nil()),
                   active(pair(X1, X2)) -> pair(X1, active(X2)),
                   active(pair(X1, X2)) -> pair(active(X1), X2),
                        active(tail(X)) -> tail(active(X)),
              active(tail(cons(X, XS))) -> mark(XS),
                    active(repItems(X)) -> repItems(active(X)),
          active(repItems(cons(X, XS))) ->
  mark(cons(X, cons(X, repItems(XS)))),
                active(repItems(nil())) -> mark(nil()),
                             s(mark(X)) -> mark(s(X)),
                               s(ok(X)) -> ok(s(X)),
                     take(X1, mark(X2)) -> mark(take(X1, X2)),
                     take(mark(X1), X2) -> mark(take(X1, X2)),
                   take(ok(X1), ok(X2)) -> ok(take(X1, X2)),
                      zip(X1, mark(X2)) -> mark(zip(X1, X2)),
                      zip(mark(X1), X2) -> mark(zip(X1, X2)),
                    zip(ok(X1), ok(X2)) -> ok(zip(X1, X2)),
                     pair(X1, mark(X2)) -> mark(pair(X1, X2)),
                     pair(mark(X1), X2) -> mark(pair(X1, X2)),
                   pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)),
                          tail(mark(X)) -> mark(tail(X)),
                            tail(ok(X)) -> ok(tail(X)),
                      repItems(mark(X)) -> mark(repItems(X)),
                        repItems(ok(X)) -> ok(repItems(X)),
                   proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)),
                            proper(0()) -> ok(0()),
                        proper(incr(X)) -> incr(proper(X)),
                        proper(oddNs()) -> ok(oddNs()),
                       proper(pairNs()) -> ok(pairNs()),
                           proper(s(X)) -> s(proper(X)),
                          proper(nil()) -> ok(nil()),
                   proper(take(X1, X2)) -> take(proper(X1), proper(X2)),
                    proper(zip(X1, X2)) -> zip(proper(X1), proper(X2)),
                   proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)),
                        proper(tail(X)) -> tail(proper(X)),
                    proper(repItems(X)) -> repItems(proper(X)),
                           top(mark(X)) -> top(proper(X)),
                             top(ok(X)) -> top(active(X))
 }
 DUP: We consider a duplicating system.
  Trs:
   {
                       cons(mark(X1), X2) -> mark(cons(X1, X2)),
                     cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)),
                            incr(mark(X)) -> mark(incr(X)),
                              incr(ok(X)) -> ok(incr(X)),
                     active(cons(X1, X2)) -> cons(active(X1), X2),
                          active(incr(X)) -> incr(active(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(s(X)) -> s(active(X)),
                     active(take(X1, X2)) -> take(X1, active(X2)),
                     active(take(X1, X2)) -> take(active(X1), X2),
                    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(X1, X2)) -> zip(X1, active(X2)),
                      active(zip(X1, X2)) -> zip(active(X1), X2),
    active(zip(cons(X, XS), cons(Y, YS))) ->
    mark(cons(pair(X, Y), zip(XS, YS))),
                   active(zip(nil(), XS)) -> mark(nil()),
                     active(pair(X1, X2)) -> pair(X1, active(X2)),
                     active(pair(X1, X2)) -> pair(active(X1), X2),
                          active(tail(X)) -> tail(active(X)),
                active(tail(cons(X, XS))) -> mark(XS),
                      active(repItems(X)) -> repItems(active(X)),
            active(repItems(cons(X, XS))) ->
    mark(cons(X, cons(X, repItems(XS)))),
                  active(repItems(nil())) -> mark(nil()),
                               s(mark(X)) -> mark(s(X)),
                                 s(ok(X)) -> ok(s(X)),
                       take(X1, mark(X2)) -> mark(take(X1, X2)),
                       take(mark(X1), X2) -> mark(take(X1, X2)),
                     take(ok(X1), ok(X2)) -> ok(take(X1, X2)),
                        zip(X1, mark(X2)) -> mark(zip(X1, X2)),
                        zip(mark(X1), X2) -> mark(zip(X1, X2)),
                      zip(ok(X1), ok(X2)) -> ok(zip(X1, X2)),
                       pair(X1, mark(X2)) -> mark(pair(X1, X2)),
                       pair(mark(X1), X2) -> mark(pair(X1, X2)),
                     pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)),
                            tail(mark(X)) -> mark(tail(X)),
                              tail(ok(X)) -> ok(tail(X)),
                        repItems(mark(X)) -> mark(repItems(X)),
                          repItems(ok(X)) -> ok(repItems(X)),
                     proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)),
                              proper(0()) -> ok(0()),
                          proper(incr(X)) -> incr(proper(X)),
                          proper(oddNs()) -> ok(oddNs()),
                         proper(pairNs()) -> ok(pairNs()),
                             proper(s(X)) -> s(proper(X)),
                            proper(nil()) -> ok(nil()),
                     proper(take(X1, X2)) -> take(proper(X1), proper(X2)),
                      proper(zip(X1, X2)) -> zip(proper(X1), proper(X2)),
                     proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)),
                          proper(tail(X)) -> tail(proper(X)),
                      proper(repItems(X)) -> repItems(proper(X)),
                             top(mark(X)) -> top(proper(X)),
                               top(ok(X)) -> top(active(X))
   }
  Fail