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)} DP: Strict: { mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> cons#(mark(X1), X2), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), mark#(0()) -> active#(0()), mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> incr#(mark(X)), mark#(incr(X)) -> active#(incr(mark(X))), mark#(oddNs()) -> active#(oddNs()), mark#(pairNs()) -> active#(pairNs()), mark#(s(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X))), mark#(s(X)) -> s#(mark(X)), mark#(nil()) -> active#(nil()), mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2)), mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2)), mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2)), mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X))), mark#(tail(X)) -> tail#(mark(X)), mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X))), mark#(repItems(X)) -> 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#(incr(cons(X, XS))) -> cons#(s(X), incr(XS)), active#(incr(cons(X, XS))) -> incr#(XS), active#(incr(cons(X, XS))) -> s#(X), active#(oddNs()) -> mark#(incr(pairNs())), active#(oddNs()) -> incr#(pairNs()), active#(pairNs()) -> mark#(cons(0(), incr(oddNs()))), active#(pairNs()) -> cons#(0(), incr(oddNs())), active#(pairNs()) -> incr#(oddNs()), active#(take(0(), XS)) -> mark#(nil()), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS)), active#(take(s(N), cons(X, XS))) -> 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(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS)), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y), 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(cons(X, XS))) -> cons#(X, cons(X, repItems(XS))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS)), active#(repItems(cons(X, XS))) -> 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)} Weak: { 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)} EDG: { (mark#(incr(X)) -> incr#(mark(X)), incr#(active(X)) -> incr#(X)) (mark#(incr(X)) -> incr#(mark(X)), incr#(mark(X)) -> incr#(X)) (mark#(tail(X)) -> tail#(mark(X)), tail#(active(X)) -> tail#(X)) (mark#(tail(X)) -> tail#(mark(X)), tail#(mark(X)) -> tail#(X)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(repItems(nil())) -> mark#(nil())) (mark#(incr(X)) -> active#(incr(mark(X))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(X, nil())) -> mark#(nil())) (mark#(incr(X)) -> active#(incr(mark(X))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(take(0(), XS)) -> mark#(nil())) (mark#(incr(X)) -> active#(incr(mark(X))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(repItems(nil())) -> mark#(nil())) (mark#(tail(X)) -> active#(tail(mark(X))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(X, nil())) -> mark#(nil())) (mark#(tail(X)) -> active#(tail(mark(X))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(take(0(), XS)) -> mark#(nil())) (mark#(tail(X)) -> active#(tail(mark(X))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS)), cons#(active(X1), X2) -> cons#(X1, X2)) (active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS)), cons#(mark(X1), X2) -> cons#(X1, X2)) (active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS)), cons#(X1, active(X2)) -> cons#(X1, X2)) (active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS)), cons#(X1, mark(X2)) -> cons#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y), pair#(active(X1), X2) -> pair#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y), pair#(mark(X1), X2) -> pair#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y), pair#(X1, active(X2)) -> pair#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y), pair#(X1, mark(X2)) -> pair#(X1, X2)) (mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2)), zip#(active(X1), X2) -> zip#(X1, X2)) (mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2)), zip#(mark(X1), X2) -> zip#(X1, X2)) (mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2)), zip#(X1, active(X2)) -> zip#(X1, X2)) (mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2)), zip#(X1, mark(X2)) -> zip#(X1, X2)) (active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS)), cons#(active(X1), X2) -> cons#(X1, X2)) (active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS)), cons#(mark(X1), X2) -> cons#(X1, X2)) (active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS)), cons#(X1, active(X2)) -> cons#(X1, X2)) (active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS)), cons#(X1, mark(X2)) -> cons#(X1, X2)) (mark#(cons(X1, X2)) -> cons#(mark(X1), X2), cons#(active(X1), X2) -> cons#(X1, X2)) (mark#(cons(X1, X2)) -> cons#(mark(X1), X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (mark#(cons(X1, X2)) -> cons#(mark(X1), X2), cons#(X1, active(X2)) -> cons#(X1, X2)) (mark#(cons(X1, X2)) -> cons#(mark(X1), X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (mark#(incr(X)) -> mark#(X), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(incr(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(tail(X)) -> tail#(mark(X))) (mark#(incr(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(incr(X)) -> mark#(X), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(incr(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(incr(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(nil()) -> active#(nil())) (mark#(incr(X)) -> mark#(X), mark#(s(X)) -> s#(mark(X))) (mark#(incr(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(incr(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> incr#(mark(X))) (mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(0()) -> active#(0())) (mark#(incr(X)) -> mark#(X), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(incr(X)) -> mark#(X), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(incr(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(tail(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> tail#(mark(X))) (mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(tail(X)) -> mark#(X), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(tail(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(tail(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(nil()) -> active#(nil())) (mark#(tail(X)) -> mark#(X), mark#(s(X)) -> s#(mark(X))) (mark#(tail(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(tail(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(tail(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(incr(X)) -> incr#(mark(X))) (mark#(tail(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(0()) -> active#(0())) (mark#(tail(X)) -> mark#(X), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(tail(X)) -> mark#(X), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(tail(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (incr#(mark(X)) -> incr#(X), incr#(active(X)) -> incr#(X)) (incr#(mark(X)) -> incr#(X), incr#(mark(X)) -> incr#(X)) (active#(incr(cons(X, XS))) -> s#(X), s#(active(X)) -> s#(X)) (active#(incr(cons(X, XS))) -> s#(X), s#(mark(X)) -> s#(X)) (s#(active(X)) -> s#(X), s#(active(X)) -> s#(X)) (s#(active(X)) -> s#(X), s#(mark(X)) -> s#(X)) (tail#(active(X)) -> tail#(X), tail#(active(X)) -> tail#(X)) (tail#(active(X)) -> tail#(X), tail#(mark(X)) -> tail#(X)) (repItems#(active(X)) -> repItems#(X), repItems#(active(X)) -> repItems#(X)) (repItems#(active(X)) -> repItems#(X), repItems#(mark(X)) -> repItems#(X)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(X1, active(X2)) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(X1, active(X2)) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(active(X1), X2) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(active(X1), X2) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(X1, active(X2)) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(X1, active(X2)) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(active(X1), X2) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(active(X1), X2) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (mark#(pairNs()) -> active#(pairNs()), active#(pairNs()) -> incr#(oddNs())) (mark#(pairNs()) -> active#(pairNs()), active#(pairNs()) -> cons#(0(), incr(oddNs()))) (mark#(pairNs()) -> active#(pairNs()), active#(pairNs()) -> mark#(cons(0(), incr(oddNs())))) (active#(take(0(), XS)) -> mark#(nil()), mark#(nil()) -> active#(nil())) (active#(zip(nil(), XS)) -> mark#(nil()), mark#(nil()) -> active#(nil())) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(repItems(X)) -> repItems#(mark(X))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(repItems(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(tail(X)) -> tail#(mark(X))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(tail(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> mark#(X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(s(X)) -> s#(mark(X))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(s(X)) -> active#(s(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(s(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(incr(X)) -> incr#(mark(X))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(incr(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(repItems(X)) -> repItems#(mark(X))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(repItems(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(tail(X)) -> tail#(mark(X))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(tail(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> mark#(X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(s(X)) -> s#(mark(X))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(s(X)) -> active#(s(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(s(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(incr(X)) -> incr#(mark(X))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(incr(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(repItems(X)) -> repItems#(mark(X))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(repItems(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(tail(X)) -> tail#(mark(X))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(tail(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pair(X1, X2)) -> mark#(X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pair(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> mark#(X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> mark#(X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(nil()) -> active#(nil())) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(s(X)) -> s#(mark(X))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(s(X)) -> active#(s(mark(X)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(s(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pairNs()) -> active#(pairNs())) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(oddNs()) -> active#(oddNs())) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(incr(X)) -> incr#(mark(X))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(incr(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(0()) -> active#(0())) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(tail(X)) -> tail#(mark(X))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(nil()) -> active#(nil())) (mark#(cons(X1, X2)) -> mark#(X1), mark#(s(X)) -> s#(mark(X))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(s(X)) -> active#(s(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(cons(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> incr#(mark(X))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(0()) -> active#(0())) (mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(tail(X)) -> tail#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(nil()) -> active#(nil())) (mark#(zip(X1, X2)) -> mark#(X1), mark#(s(X)) -> s#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(s(X)) -> active#(s(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(zip(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(zip(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(incr(X)) -> incr#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(0()) -> active#(0())) (mark#(zip(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> take#(N, XS), take#(active(X1), X2) -> take#(X1, X2)) (active#(take(s(N), cons(X, XS))) -> take#(N, XS), take#(mark(X1), X2) -> take#(X1, X2)) (active#(take(s(N), cons(X, XS))) -> take#(N, XS), take#(X1, active(X2)) -> take#(X1, X2)) (active#(take(s(N), cons(X, XS))) -> take#(N, XS), take#(X1, mark(X2)) -> take#(X1, X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(take(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(tail(X)) -> tail#(mark(X))) (mark#(take(X1, X2)) -> mark#(X2), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(take(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(nil()) -> active#(nil())) (mark#(take(X1, X2)) -> mark#(X2), mark#(s(X)) -> s#(mark(X))) (mark#(take(X1, X2)) -> mark#(X2), mark#(s(X)) -> active#(s(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(s(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(pairNs()) -> active#(pairNs())) (mark#(take(X1, X2)) -> mark#(X2), mark#(oddNs()) -> active#(oddNs())) (mark#(take(X1, X2)) -> mark#(X2), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(incr(X)) -> incr#(mark(X))) (mark#(take(X1, X2)) -> mark#(X2), mark#(incr(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(0()) -> active#(0())) (mark#(take(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(take(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> tail#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(nil()) -> active#(nil())) (mark#(pair(X1, X2)) -> mark#(X2), mark#(s(X)) -> s#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(s(X)) -> active#(s(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(s(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pairNs()) -> active#(pairNs())) (mark#(pair(X1, X2)) -> mark#(X2), mark#(oddNs()) -> active#(oddNs())) (mark#(pair(X1, X2)) -> mark#(X2), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(incr(X)) -> incr#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(incr(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(0()) -> active#(0())) (mark#(pair(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(repItems(nil())) -> mark#(nil())) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(X, nil())) -> mark#(nil())) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(take(0(), XS)) -> mark#(nil())) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(repItems(nil())) -> mark#(nil())) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(zip(X, nil())) -> mark#(nil())) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(take(0(), XS)) -> mark#(nil())) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (active#(pairNs()) -> mark#(cons(0(), incr(oddNs()))), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (active#(pairNs()) -> mark#(cons(0(), incr(oddNs()))), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (active#(pairNs()) -> mark#(cons(0(), incr(oddNs()))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(incr(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(incr(X)) -> incr#(mark(X))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(s(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(s(X)) -> active#(s(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(s(X)) -> s#(mark(X))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> mark#(X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(tail(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(tail(X)) -> tail#(mark(X))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(repItems(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(take(0(), XS)) -> mark#(nil())) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(X, nil())) -> mark#(nil())) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(repItems(nil())) -> mark#(nil())) (active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS), zip#(X1, mark(X2)) -> zip#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS), zip#(X1, active(X2)) -> zip#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS), zip#(mark(X1), X2) -> zip#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS), zip#(active(X1), X2) -> zip#(X1, X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(0()) -> active#(0())) (mark#(zip(X1, X2)) -> mark#(X2), mark#(incr(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(incr(X)) -> incr#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(oddNs()) -> active#(oddNs())) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pairNs()) -> active#(pairNs())) (mark#(zip(X1, X2)) -> mark#(X2), mark#(s(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(s(X)) -> active#(s(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(s(X)) -> s#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(nil()) -> active#(nil())) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(tail(X)) -> tail#(mark(X))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(incr(cons(X, XS))) -> s#(X)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(take(0(), XS)) -> mark#(nil())) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(zip(X, nil())) -> mark#(nil())) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), active#(repItems(nil())) -> mark#(nil())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(0()) -> active#(0())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(incr(X)) -> incr#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(s(X)) -> active#(s(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(s(X)) -> s#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(nil()) -> active#(nil())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(tail(X)) -> tail#(mark(X))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(take(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(take(X1, X2)) -> mark#(X1), mark#(0()) -> active#(0())) (mark#(take(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(incr(X)) -> incr#(mark(X))) (mark#(take(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(take(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(take(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(s(X)) -> active#(s(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(s(X)) -> s#(mark(X))) (mark#(take(X1, X2)) -> mark#(X1), mark#(nil()) -> active#(nil())) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(take(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(take(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(tail(X)) -> tail#(mark(X))) (mark#(take(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> repItems#(mark(X))) (active#(repItems(cons(X, XS))) -> repItems#(XS), repItems#(mark(X)) -> repItems#(X)) (active#(repItems(cons(X, XS))) -> repItems#(XS), repItems#(active(X)) -> repItems#(X)) (active#(incr(cons(X, XS))) -> incr#(XS), incr#(mark(X)) -> incr#(X)) (active#(incr(cons(X, XS))) -> incr#(XS), incr#(active(X)) -> incr#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(incr(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(incr(X)) -> incr#(mark(X))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(s(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(s(X)) -> active#(s(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(s(X)) -> s#(mark(X))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> mark#(X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(tail(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(tail(X)) -> tail#(mark(X))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(repItems(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(repItems(X)) -> repItems#(mark(X))) (active#(repItems(nil())) -> mark#(nil()), mark#(nil()) -> active#(nil())) (active#(zip(X, nil())) -> mark#(nil()), mark#(nil()) -> active#(nil())) (mark#(oddNs()) -> active#(oddNs()), active#(oddNs()) -> mark#(incr(pairNs()))) (mark#(oddNs()) -> active#(oddNs()), active#(oddNs()) -> incr#(pairNs())) (pair#(active(X1), X2) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(active(X1), X2) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(active(X1), X2) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)) (pair#(active(X1), X2) -> pair#(X1, X2), pair#(active(X1), X2) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(active(X1), X2) -> pair#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(X1, active(X2)) -> zip#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)) (zip#(X1, active(X2)) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(X1, active(X2)) -> zip#(X1, X2), zip#(X1, active(X2)) -> zip#(X1, X2)) (zip#(X1, active(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(X1, active(X2)) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)) (take#(active(X1), X2) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(active(X1), X2) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(active(X1), X2) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)) (take#(active(X1), X2) -> take#(X1, X2), take#(active(X1), X2) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(active(X1), X2) -> take#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(X1, active(X2)) -> cons#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)) (cons#(X1, active(X2)) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(X1, active(X2)) -> cons#(X1, X2), cons#(X1, active(X2)) -> cons#(X1, X2)) (cons#(X1, active(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(X1, active(X2)) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)) (repItems#(mark(X)) -> repItems#(X), repItems#(mark(X)) -> repItems#(X)) (repItems#(mark(X)) -> repItems#(X), repItems#(active(X)) -> repItems#(X)) (tail#(mark(X)) -> tail#(X), tail#(mark(X)) -> tail#(X)) (tail#(mark(X)) -> tail#(X), tail#(active(X)) -> tail#(X)) (s#(mark(X)) -> s#(X), s#(mark(X)) -> s#(X)) (s#(mark(X)) -> s#(X), s#(active(X)) -> s#(X)) (incr#(active(X)) -> incr#(X), incr#(mark(X)) -> incr#(X)) (incr#(active(X)) -> incr#(X), incr#(active(X)) -> incr#(X)) (mark#(repItems(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(repItems(X)) -> mark#(X), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(repItems(X)) -> mark#(X), mark#(0()) -> active#(0())) (mark#(repItems(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(incr(X)) -> incr#(mark(X))) (mark#(repItems(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(repItems(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(repItems(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(s(X)) -> s#(mark(X))) (mark#(repItems(X)) -> mark#(X), mark#(nil()) -> active#(nil())) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(repItems(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(repItems(X)) -> mark#(X), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(repItems(X)) -> mark#(X), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(repItems(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(tail(X)) -> tail#(mark(X))) (mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> repItems#(mark(X))) (mark#(s(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(cons(X1, X2)) -> cons#(mark(X1), X2)) (mark#(s(X)) -> mark#(X), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2))) (mark#(s(X)) -> mark#(X), mark#(0()) -> active#(0())) (mark#(s(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(incr(X)) -> incr#(mark(X))) (mark#(s(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(s(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(s(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(s(X)) -> s#(mark(X))) (mark#(s(X)) -> mark#(X), mark#(nil()) -> active#(nil())) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> take#(mark(X1), mark(X2))) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> zip#(mark(X1), mark(X2))) (mark#(s(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(s(X)) -> mark#(X), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2)))) (mark#(s(X)) -> mark#(X), mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2))) (mark#(s(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(tail(X)) -> tail#(mark(X))) (mark#(s(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(repItems(X)) -> repItems#(mark(X))) (active#(oddNs()) -> mark#(incr(pairNs())), mark#(incr(X)) -> mark#(X)) (active#(oddNs()) -> mark#(incr(pairNs())), mark#(incr(X)) -> incr#(mark(X))) (active#(oddNs()) -> mark#(incr(pairNs())), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS)), cons#(X1, mark(X2)) -> cons#(X1, X2)) (active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS)), cons#(X1, active(X2)) -> cons#(X1, X2)) (active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS)), cons#(mark(X1), X2) -> cons#(X1, X2)) (active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS)), cons#(active(X1), X2) -> cons#(X1, X2)) (mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2)), pair#(X1, mark(X2)) -> pair#(X1, X2)) (mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2)), pair#(X1, active(X2)) -> pair#(X1, X2)) (mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2)), pair#(mark(X1), X2) -> pair#(X1, X2)) (mark#(pair(X1, X2)) -> pair#(mark(X1), mark(X2)), pair#(active(X1), X2) -> pair#(X1, X2)) (mark#(take(X1, X2)) -> take#(mark(X1), mark(X2)), take#(X1, mark(X2)) -> take#(X1, X2)) (mark#(take(X1, X2)) -> take#(mark(X1), mark(X2)), take#(X1, active(X2)) -> take#(X1, X2)) (mark#(take(X1, X2)) -> take#(mark(X1), mark(X2)), take#(mark(X1), X2) -> take#(X1, X2)) (mark#(take(X1, X2)) -> take#(mark(X1), mark(X2)), take#(active(X1), X2) -> take#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS)), cons#(X1, mark(X2)) -> cons#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS)), cons#(X1, active(X2)) -> cons#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS)), cons#(mark(X1), X2) -> cons#(X1, X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS)), cons#(active(X1), X2) -> cons#(X1, X2)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(take(0(), XS)) -> mark#(nil())) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(X, nil())) -> mark#(nil())) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(repItems(nil())) -> mark#(nil())) (mark#(s(X)) -> active#(s(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(s(X)) -> active#(s(mark(X))), active#(incr(cons(X, XS))) -> cons#(s(X), incr(XS))) (mark#(s(X)) -> active#(s(mark(X))), active#(incr(cons(X, XS))) -> incr#(XS)) (mark#(s(X)) -> active#(s(mark(X))), active#(incr(cons(X, XS))) -> s#(X)) (mark#(s(X)) -> active#(s(mark(X))), active#(take(0(), XS)) -> mark#(nil())) (mark#(s(X)) -> active#(s(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(s(X)) -> active#(s(mark(X))), active#(take(s(N), cons(X, XS))) -> cons#(X, take(N, XS))) (mark#(s(X)) -> active#(s(mark(X))), active#(take(s(N), cons(X, XS))) -> take#(N, XS)) (mark#(s(X)) -> active#(s(mark(X))), active#(zip(X, nil())) -> mark#(nil())) (mark#(s(X)) -> active#(s(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(s(X)) -> active#(s(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> cons#(pair(X, Y), zip(XS, YS))) (mark#(s(X)) -> active#(s(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> zip#(XS, YS)) (mark#(s(X)) -> active#(s(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> pair#(X, Y)) (mark#(s(X)) -> active#(s(mark(X))), active#(zip(nil(), XS)) -> mark#(nil())) (mark#(s(X)) -> active#(s(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(s(X)) -> active#(s(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(s(X)) -> active#(s(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS)))) (mark#(s(X)) -> active#(s(mark(X))), active#(repItems(cons(X, XS))) -> cons#(X, repItems(XS))) (mark#(s(X)) -> active#(s(mark(X))), active#(repItems(cons(X, XS))) -> repItems#(XS)) (mark#(s(X)) -> active#(s(mark(X))), active#(repItems(nil())) -> mark#(nil())) (mark#(repItems(X)) -> repItems#(mark(X)), repItems#(mark(X)) -> repItems#(X)) (mark#(repItems(X)) -> repItems#(mark(X)), repItems#(active(X)) -> repItems#(X)) (mark#(s(X)) -> s#(mark(X)), s#(mark(X)) -> s#(X)) (mark#(s(X)) -> s#(mark(X)), s#(active(X)) -> s#(X)) (active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS))), cons#(X1, mark(X2)) -> cons#(X1, X2)) (active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS))), cons#(X1, active(X2)) -> cons#(X1, X2)) (active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS))), cons#(mark(X1), X2) -> cons#(X1, X2)) (active#(repItems(cons(X, XS))) -> cons#(X, cons(X, repItems(XS))), cons#(active(X1), X2) -> cons#(X1, X2)) } SCCS: Scc: { repItems#(mark(X)) -> repItems#(X), repItems#(active(X)) -> repItems#(X)} Scc: { tail#(mark(X)) -> tail#(X), tail#(active(X)) -> tail#(X)} Scc: { 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)} Scc: { 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)} Scc: { 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)} Scc: { s#(mark(X)) -> s#(X), s#(active(X)) -> s#(X)} Scc: { incr#(mark(X)) -> incr#(X), incr#(active(X)) -> incr#(X)} Scc: { 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)} Scc: { mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X))), mark#(oddNs()) -> active#(oddNs()), mark#(pairNs()) -> active#(pairNs()), mark#(s(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X))), mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X))), mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(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(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), active#(tail(cons(X, XS))) -> mark#(XS), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))} SCC: Strict: { repItems#(mark(X)) -> repItems#(X), repItems#(active(X)) -> repItems#(X)} Weak: { 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)} SPSC: Simple Projection: pi(repItems#) = 0 Strict: {repItems#(active(X)) -> repItems#(X)} EDG: {(repItems#(active(X)) -> repItems#(X), repItems#(active(X)) -> repItems#(X))} SCCS: Scc: {repItems#(active(X)) -> repItems#(X)} SCC: Strict: {repItems#(active(X)) -> repItems#(X)} Weak: { 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)} SPSC: Simple Projection: pi(repItems#) = 0 Strict: {} Qed SCC: Strict: { tail#(mark(X)) -> tail#(X), tail#(active(X)) -> tail#(X)} Weak: { 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)} SPSC: Simple Projection: pi(tail#) = 0 Strict: {tail#(active(X)) -> tail#(X)} EDG: {(tail#(active(X)) -> tail#(X), tail#(active(X)) -> tail#(X))} SCCS: Scc: {tail#(active(X)) -> tail#(X)} SCC: Strict: {tail#(active(X)) -> tail#(X)} Weak: { 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)} SPSC: Simple Projection: pi(tail#) = 0 Strict: {} Qed SCC: Strict: { 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)} Weak: { 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)} SPSC: Simple Projection: pi(pair#) = 0 Strict: { pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)} EDG: {(pair#(X1, active(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(mark(X1), X2) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2))} SCCS: Scc: { pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)} SCC: Strict: { pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2), pair#(mark(X1), X2) -> pair#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(pair#) = 0 Strict: { pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)} EDG: {(pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)) (pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, mark(X2)) -> pair#(X1, X2)) (pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2))} SCCS: Scc: { pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)} SCC: Strict: { pair#(X1, mark(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(pair#) = 1 Strict: {pair#(X1, active(X2)) -> pair#(X1, X2)} EDG: {(pair#(X1, active(X2)) -> pair#(X1, X2), pair#(X1, active(X2)) -> pair#(X1, X2))} SCCS: Scc: {pair#(X1, active(X2)) -> pair#(X1, X2)} SCC: Strict: {pair#(X1, active(X2)) -> pair#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(pair#) = 1 Strict: {} Qed SCC: Strict: { 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)} Weak: { 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)} SPSC: Simple Projection: pi(zip#) = 1 Strict: { zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)} EDG: {(zip#(mark(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(active(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2))} SCCS: Scc: { zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)} SCC: Strict: { zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2), zip#(active(X1), X2) -> zip#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(zip#) = 0 Strict: {zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)} EDG: {(zip#(mark(X1), X2) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)) (zip#(mark(X1), X2) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(X1, mark(X2)) -> zip#(X1, X2)) (zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2))} SCCS: Scc: {zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)} SCC: Strict: {zip#(X1, mark(X2)) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(zip#) = 1 Strict: {zip#(mark(X1), X2) -> zip#(X1, X2)} EDG: {(zip#(mark(X1), X2) -> zip#(X1, X2), zip#(mark(X1), X2) -> zip#(X1, X2))} SCCS: Scc: {zip#(mark(X1), X2) -> zip#(X1, X2)} SCC: Strict: {zip#(mark(X1), X2) -> zip#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(zip#) = 0 Strict: {} Qed SCC: Strict: { 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)} Weak: { 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)} SPSC: Simple Projection: pi(take#) = 0 Strict: { take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)} EDG: {(take#(X1, active(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(mark(X1), X2) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2))} SCCS: Scc: { take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)} SCC: Strict: { take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2), take#(mark(X1), X2) -> take#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(take#) = 0 Strict: { take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)} EDG: {(take#(X1, active(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)) (take#(X1, active(X2)) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, mark(X2)) -> take#(X1, X2)) (take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2))} SCCS: Scc: { take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)} SCC: Strict: { take#(X1, mark(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(take#) = 1 Strict: {take#(X1, active(X2)) -> take#(X1, X2)} EDG: {(take#(X1, active(X2)) -> take#(X1, X2), take#(X1, active(X2)) -> take#(X1, X2))} SCCS: Scc: {take#(X1, active(X2)) -> take#(X1, X2)} SCC: Strict: {take#(X1, active(X2)) -> take#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(take#) = 1 Strict: {} Qed SCC: Strict: { s#(mark(X)) -> s#(X), s#(active(X)) -> s#(X)} Weak: { 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)} SPSC: Simple Projection: pi(s#) = 0 Strict: {s#(active(X)) -> s#(X)} EDG: {(s#(active(X)) -> s#(X), s#(active(X)) -> s#(X))} SCCS: Scc: {s#(active(X)) -> s#(X)} SCC: Strict: {s#(active(X)) -> s#(X)} Weak: { 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)} SPSC: Simple Projection: pi(s#) = 0 Strict: {} Qed SCC: Strict: { incr#(mark(X)) -> incr#(X), incr#(active(X)) -> incr#(X)} Weak: { 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)} SPSC: Simple Projection: pi(incr#) = 0 Strict: {incr#(active(X)) -> incr#(X)} EDG: {(incr#(active(X)) -> incr#(X), incr#(active(X)) -> incr#(X))} SCCS: Scc: {incr#(active(X)) -> incr#(X)} SCC: Strict: {incr#(active(X)) -> incr#(X)} Weak: { 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)} SPSC: Simple Projection: pi(incr#) = 0 Strict: {} Qed SCC: Strict: { 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)} Weak: { 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)} SPSC: Simple Projection: pi(cons#) = 1 Strict: { cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)} EDG: {(cons#(mark(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(active(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2))} SCCS: Scc: { cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)} SCC: Strict: { cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2), cons#(active(X1), X2) -> cons#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(cons#) = 0 Strict: {cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)} EDG: {(cons#(mark(X1), X2) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)) (cons#(mark(X1), X2) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2)) (cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2))} SCCS: Scc: {cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)} SCC: Strict: {cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(mark(X1), X2) -> cons#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(cons#) = 0 Strict: {cons#(X1, mark(X2)) -> cons#(X1, X2)} EDG: {(cons#(X1, mark(X2)) -> cons#(X1, X2), cons#(X1, mark(X2)) -> cons#(X1, X2))} SCCS: Scc: {cons#(X1, mark(X2)) -> cons#(X1, X2)} SCC: Strict: {cons#(X1, mark(X2)) -> cons#(X1, X2)} Weak: { 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)} SPSC: Simple Projection: pi(cons#) = 1 Strict: {} Qed SCC: Strict: { mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> active#(cons(mark(X1), X2)), mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X))), mark#(oddNs()) -> active#(oddNs()), mark#(pairNs()) -> active#(pairNs()), mark#(s(X)) -> mark#(X), mark#(s(X)) -> active#(s(mark(X))), mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> active#(pair(mark(X1), mark(X2))), mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X))), mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(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(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), active#(tail(cons(X, XS))) -> mark#(XS), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))} Weak: { 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)} POLY: Argument Filtering: pi(repItems) = [], pi(tail) = [], pi(pair) = [], pi(zip) = [], pi(take) = [], pi(nil) = [], pi(s) = [], pi(pairNs) = [], pi(active#) = 0, pi(active) = [], pi(oddNs) = [], pi(incr) = [], pi(0) = [], pi(cons) = [], pi(mark#) = [], pi(mark) = [] Usable Rules: {} Interpretation: [mark#] = 1, [pair] = 0, [zip] = 1, [take] = 1, [cons] = 0, [repItems] = 1, [tail] = 1, [s] = 0, [incr] = 1, [pairNs] = 1, [oddNs] = 1 Strict: { mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X))), mark#(oddNs()) -> active#(oddNs()), mark#(pairNs()) -> active#(pairNs()), mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X))), mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(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(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), active#(tail(cons(X, XS))) -> mark#(XS), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))} Weak: { 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)} EDG: { (mark#(s(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(s(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(s(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(s(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(s(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(s(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(s(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(s(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(repItems(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(repItems(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(repItems(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(repItems(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(repItems(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(repItems(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(repItems(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(repItems(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(repItems(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(tail(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> mark#(X2)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(take(X1, X2)) -> mark#(X1)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(s(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(incr(X)) -> mark#(X)) (active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(repItems(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(tail(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> mark#(X2)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(take(X1, X2)) -> mark#(X1)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(s(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(incr(X)) -> mark#(X)) (active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS)))), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(take(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(take(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(take(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(pair(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(oddNs()) -> active#(oddNs()), active#(oddNs()) -> mark#(incr(pairNs()))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(incr(X)) -> active#(incr(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(incr(X)) -> active#(incr(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(s(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(pairNs()) -> active#(pairNs())) (mark#(zip(X1, X2)) -> mark#(X2), mark#(oddNs()) -> active#(oddNs())) (mark#(zip(X1, X2)) -> mark#(X2), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X2), mark#(incr(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(tail(X)) -> active#(tail(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(tail(X)) -> active#(tail(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(repItems(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(tail(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> mark#(X2)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(take(X1, X2)) -> mark#(X1)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(s(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(incr(X)) -> mark#(X)) (active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(pairNs()) -> mark#(cons(0(), incr(oddNs()))), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(incr(cons(X, XS))) -> mark#(cons(s(X), incr(XS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(take(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS)))) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(tail(cons(X, XS))) -> mark#(XS)) (mark#(repItems(X)) -> active#(repItems(mark(X))), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(incr(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(oddNs()) -> active#(oddNs())) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pairNs()) -> active#(pairNs())) (mark#(pair(X1, X2)) -> mark#(X2), mark#(s(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(pair(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> mark#(X)) (mark#(pair(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(incr(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(oddNs()) -> active#(oddNs())) (mark#(take(X1, X2)) -> mark#(X2), mark#(pairNs()) -> active#(pairNs())) (mark#(take(X1, X2)) -> mark#(X2), mark#(s(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(take(X1, X2)) -> mark#(X2), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(take(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(take(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> mark#(X)) (mark#(take(X1, X2)) -> mark#(X2), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(pairNs()) -> active#(pairNs()), active#(pairNs()) -> mark#(cons(0(), incr(oddNs())))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(cons(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(incr(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(oddNs()) -> active#(oddNs())) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pairNs()) -> active#(pairNs())) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(s(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> mark#(X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> mark#(X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pair(X1, X2)) -> mark#(X1)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(pair(X1, X2)) -> mark#(X2)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(tail(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(repItems(X)) -> mark#(X)) (active#(tail(cons(X, XS))) -> mark#(XS), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(zip(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(zip(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(zip(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(oddNs()) -> active#(oddNs())) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pairNs()) -> active#(pairNs())) (mark#(cons(X1, X2)) -> mark#(X1), mark#(s(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(tail(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(cons(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> mark#(X)) (mark#(cons(X1, X2)) -> mark#(X1), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(cons(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(incr(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(incr(X)) -> active#(incr(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(s(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> mark#(X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> mark#(X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(pair(X1, X2)) -> mark#(X1)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(pair(X1, X2)) -> mark#(X2)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(tail(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(tail(X)) -> active#(tail(mark(X)))) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(repItems(X)) -> mark#(X)) (active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), mark#(repItems(X)) -> active#(repItems(mark(X)))) (active#(oddNs()) -> mark#(incr(pairNs())), mark#(incr(X)) -> mark#(X)) (active#(oddNs()) -> mark#(incr(pairNs())), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(tail(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(tail(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(tail(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(tail(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(tail(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(tail(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(tail(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(tail(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(cons(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(oddNs()) -> active#(oddNs())) (mark#(incr(X)) -> mark#(X), mark#(pairNs()) -> active#(pairNs())) (mark#(incr(X)) -> mark#(X), mark#(s(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X2)) (mark#(incr(X)) -> mark#(X), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2)))) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> mark#(X2)) (mark#(incr(X)) -> mark#(X), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2)))) (mark#(incr(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X1)) (mark#(incr(X)) -> mark#(X), mark#(pair(X1, X2)) -> mark#(X2)) (mark#(incr(X)) -> mark#(X), mark#(tail(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X)))) (mark#(incr(X)) -> mark#(X), mark#(repItems(X)) -> mark#(X)) (mark#(incr(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(X)))) } SCCS: Scc: { mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X))), mark#(oddNs()) -> active#(oddNs()), mark#(pairNs()) -> active#(pairNs()), mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X))), mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(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(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), active#(tail(cons(X, XS))) -> mark#(XS), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))} SCC: Strict: { mark#(cons(X1, X2)) -> mark#(X1), mark#(incr(X)) -> mark#(X), mark#(incr(X)) -> active#(incr(mark(X))), mark#(oddNs()) -> active#(oddNs()), mark#(pairNs()) -> active#(pairNs()), mark#(s(X)) -> mark#(X), mark#(take(X1, X2)) -> mark#(X1), mark#(take(X1, X2)) -> mark#(X2), mark#(take(X1, X2)) -> active#(take(mark(X1), mark(X2))), mark#(zip(X1, X2)) -> mark#(X1), mark#(zip(X1, X2)) -> mark#(X2), mark#(zip(X1, X2)) -> active#(zip(mark(X1), mark(X2))), mark#(pair(X1, X2)) -> mark#(X1), mark#(pair(X1, X2)) -> mark#(X2), mark#(tail(X)) -> mark#(X), mark#(tail(X)) -> active#(tail(mark(X))), mark#(repItems(X)) -> mark#(X), mark#(repItems(X)) -> active#(repItems(mark(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(s(N), cons(X, XS))) -> mark#(cons(X, take(N, XS))), active#(zip(cons(X, XS), cons(Y, YS))) -> mark#(cons(pair(X, Y), zip(XS, YS))), active#(tail(cons(X, XS))) -> mark#(XS), active#(repItems(cons(X, XS))) -> mark#(cons(X, cons(X, repItems(XS))))} Weak: { 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