MAYBE Time: 0.088104 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: DP: { 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} 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} EDG: { (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# s X -> s# mark X, s# active X -> s# X) (mark# s X -> s# mark X, s# mark X -> s# X) (mark# repItems X -> repItems# mark X, repItems# active X -> repItems# X) (mark# repItems X -> repItems# mark X, repItems# mark X -> repItems# X) (mark# s X -> active# s mark X, active# repItems nil() -> mark# nil()) (mark# s X -> active# s mark X, active# repItems cons(X, XS) -> 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) -> 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 -> active# s mark X, active# tail cons(X, XS) -> mark# XS) (mark# s X -> active# s mark X, active# zip(nil(), XS) -> mark# nil()) (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(cons(X, XS), cons(Y, YS)) -> 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)) -> mark# cons(pair(X, Y), zip(XS, YS))) (mark# s X -> active# s mark X, active# zip(X, nil()) -> mark# nil()) (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# 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)) -> mark# cons(X, take(N, XS))) (mark# s X -> active# s mark X, active# take(0(), XS) -> mark# nil()) (mark# s X -> active# s mark X, active# incr cons(X, XS) -> s# X) (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) -> cons#(s X, incr XS)) (mark# s X -> active# s mark X, active# incr cons(X, XS) -> mark# cons(s X, incr XS)) (mark# repItems X -> active# repItems mark X, active# repItems nil() -> mark# nil()) (mark# repItems X -> active# repItems mark X, active# repItems cons(X, XS) -> 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) -> 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 -> active# repItems mark X, active# tail cons(X, XS) -> mark# XS) (mark# repItems X -> active# repItems mark X, active# zip(nil(), XS) -> mark# nil()) (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(cons(X, XS), cons(Y, YS)) -> 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)) -> mark# cons(pair(X, Y), zip(XS, YS))) (mark# repItems X -> active# repItems mark X, active# zip(X, nil()) -> mark# nil()) (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# 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)) -> mark# cons(X, take(N, XS))) (mark# repItems X -> active# repItems mark X, active# take(0(), XS) -> mark# nil()) (mark# repItems X -> active# repItems mark X, active# incr cons(X, XS) -> s# X) (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) -> cons#(s X, incr XS)) (mark# repItems X -> active# repItems 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)) (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) (cons#(X1, active X2) -> cons#(X1, X2), cons#(active X1, 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#(X1, active X2) -> cons#(X1, X2)) (cons#(X1, active X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (cons#(active X1, X2) -> cons#(X1, X2), cons#(active X1, 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#(X1, active X2) -> cons#(X1, X2)) (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (take#(X1, active X2) -> take#(X1, X2), take#(active X1, 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#(X1, active X2) -> take#(X1, X2)) (take#(X1, active X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (take#(active X1, X2) -> take#(X1, X2), take#(active X1, 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#(X1, active X2) -> take#(X1, X2)) (take#(active X1, X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (zip#(X1, active X2) -> zip#(X1, X2), zip#(active X1, 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#(X1, active X2) -> zip#(X1, X2)) (zip#(X1, active X2) -> zip#(X1, X2), zip#(X1, mark X2) -> zip#(X1, X2)) (zip#(active X1, X2) -> zip#(X1, X2), zip#(active X1, 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#(X1, active X2) -> zip#(X1, X2)) (zip#(active X1, X2) -> zip#(X1, X2), zip#(X1, mark X2) -> zip#(X1, X2)) (pair#(X1, active X2) -> pair#(X1, X2), pair#(active X1, 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#(X1, active X2) -> pair#(X1, X2)) (pair#(X1, active X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2)) (pair#(active X1, X2) -> pair#(X1, X2), pair#(active X1, 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#(X1, active X2) -> pair#(X1, X2)) (pair#(active X1, X2) -> pair#(X1, X2), 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)) (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) (mark# s X -> mark# X, mark# repItems X -> repItems# mark X) (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 -> tail# 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) -> pair#(mark X1, 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) -> mark# X2) (mark# s X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# zip(X1, X2) -> zip#(mark X1, 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) -> mark# X2) (mark# s X -> mark# X, mark# zip(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# take(X1, X2) -> take#(mark X1, 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) -> mark# X2) (mark# s X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# nil() -> active# nil()) (mark# s X -> mark# X, mark# s X -> s# mark X) (mark# s X -> mark# X, mark# s X -> active# s mark X) (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 -> incr# mark X) (mark# s X -> mark# X, mark# incr X -> mark# X) (mark# s X -> mark# X, mark# 0() -> active# 0()) (mark# s X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# s X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# s X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# repItems X -> mark# X, mark# repItems X -> repItems# mark X) (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 -> tail# 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) -> pair#(mark X1, 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) -> mark# X2) (mark# repItems X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# repItems X -> mark# X, mark# zip(X1, X2) -> zip#(mark X1, 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) -> mark# X2) (mark# repItems X -> mark# X, mark# zip(X1, X2) -> mark# X1) (mark# repItems X -> mark# X, mark# take(X1, X2) -> take#(mark X1, 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) -> mark# X2) (mark# repItems X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# repItems X -> mark# X, mark# nil() -> active# nil()) (mark# repItems X -> mark# X, mark# s X -> s# mark X) (mark# repItems X -> mark# X, mark# s X -> active# s mark X) (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 -> incr# mark X) (mark# repItems X -> mark# X, mark# incr X -> mark# X) (mark# repItems X -> mark# X, mark# 0() -> active# 0()) (mark# repItems X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# repItems X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# repItems X -> mark# X, mark# cons(X1, X2) -> mark# X1) (incr# active X -> incr# X, incr# active X -> incr# X) (incr# active X -> incr# X, incr# mark X -> incr# X) (s# mark X -> s# X, s# active X -> s# X) (s# mark X -> s# X, s# mark X -> s# X) (tail# mark X -> tail# X, tail# active X -> tail# X) (tail# mark X -> tail# X, tail# mark X -> tail# X) (repItems# mark X -> repItems# X, repItems# active X -> repItems# X) (repItems# mark X -> repItems# X, repItems# mark X -> repItems# X) (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# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS), zip#(active X1, 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#(X1, active X2) -> zip#(X1, X2)) (active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS), zip#(X1, mark X2) -> zip#(X1, X2)) (active# incr cons(X, XS) -> incr# XS, incr# active X -> incr# X) (active# incr cons(X, XS) -> incr# XS, incr# mark X -> incr# X) (active# repItems cons(X, XS) -> repItems# XS, repItems# active X -> repItems# X) (active# repItems cons(X, XS) -> repItems# XS, repItems# mark X -> repItems# X) (mark# take(X1, X2) -> mark# X1, mark# repItems X -> repItems# mark X) (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 -> tail# 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) -> pair#(mark X1, 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) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# zip(X1, X2) -> zip#(mark X1, 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) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# zip(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, 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) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# take(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# take(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (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 -> incr# mark X) (mark# take(X1, X2) -> mark# X1, mark# incr X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# repItems X -> repItems# mark X) (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 -> tail# 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) -> pair#(mark X1, 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) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# zip(X1, X2) -> zip#(mark X1, 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) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# zip(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, 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) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# pair(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# pair(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (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 -> incr# mark X) (mark# pair(X1, X2) -> mark# X1, mark# incr X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# pair(X1, X2) -> mark# X1, 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)) -> pair#(X, Y), pair#(X1, mark 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#(mark X1, X2) -> pair#(X1, X2)) (active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y), pair#(active X1, X2) -> pair#(X1, X2)) (mark# zip(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# zip(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# zip(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# zip(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# zip(X1, X2) -> mark# X1, mark# incr X -> mark# X) (mark# zip(X1, X2) -> mark# X1, mark# incr X -> incr# 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# s X -> active# s mark X) (mark# zip(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# zip(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (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# take(X1, X2) -> 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# zip(X1, X2) -> 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# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# zip(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, 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# tail X -> 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# zip(X1, X2) -> mark# X1, mark# repItems X -> repItems# mark X) (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# cons(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# cons(X1, X2) -> mark# X1, mark# incr X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# incr X -> incr# 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# s X -> active# s mark X) (mark# cons(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# cons(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (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# take(X1, X2) -> 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# zip(X1, X2) -> 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# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, 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# tail X -> 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) (mark# cons(X1, X2) -> mark# X1, mark# repItems X -> repItems# mark X) (active# tail cons(X, XS) -> mark# XS, mark# cons(X1, X2) -> mark# X1) (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) -> active# cons(mark X1, X2)) (active# tail cons(X, XS) -> mark# XS, mark# 0() -> active# 0()) (active# tail cons(X, XS) -> mark# XS, mark# incr X -> 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 -> 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# s X -> active# s mark X) (active# tail cons(X, XS) -> mark# XS, mark# s X -> s# mark X) (active# tail cons(X, XS) -> mark# XS, mark# nil() -> active# nil()) (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# take(X1, X2) -> 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# zip(X1, X2) -> 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# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# tail cons(X, XS) -> mark# XS, mark# pair(X1, X2) -> pair#(mark X1, 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# tail X -> 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) (active# tail cons(X, XS) -> mark# XS, 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()) (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()) (repItems# active X -> repItems# X, repItems# mark X -> repItems# X) (repItems# active X -> repItems# X, repItems# active X -> repItems# X) (tail# active X -> tail# X, tail# mark X -> tail# X) (tail# active X -> tail# X, tail# active X -> tail# X) (s# active X -> s# X, s# mark X -> s# X) (s# active X -> s# X, s# active X -> s# X) (active# incr cons(X, XS) -> s# X, s# mark X -> s# X) (active# incr cons(X, XS) -> s# X, s# active X -> s# X) (incr# mark X -> incr# X, incr# mark X -> incr# X) (incr# mark X -> incr# X, incr# active X -> incr# X) (mark# tail X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# tail X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# tail X -> mark# X, mark# 0() -> active# 0()) (mark# tail X -> mark# X, mark# incr X -> mark# X) (mark# tail X -> mark# X, mark# incr X -> incr# 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# s X -> active# s mark X) (mark# tail X -> mark# X, mark# s X -> s# mark X) (mark# tail X -> mark# X, mark# nil() -> active# nil()) (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# take(X1, X2) -> 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# zip(X1, X2) -> 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# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# tail X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, 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# tail X -> 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# tail X -> mark# X, mark# repItems X -> repItems# mark X) (mark# incr X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# incr X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# incr X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# incr X -> mark# X, mark# 0() -> active# 0()) (mark# incr X -> mark# X, mark# incr X -> mark# X) (mark# incr X -> mark# X, mark# incr X -> incr# 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# s X -> active# s mark X) (mark# incr X -> mark# X, mark# s X -> s# mark X) (mark# incr X -> mark# X, mark# nil() -> active# nil()) (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# take(X1, X2) -> 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# zip(X1, X2) -> 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# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# incr X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, 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# tail X -> 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) (mark# incr X -> mark# X, mark# repItems X -> 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# 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# take(s N, cons(X, XS)) -> take#(N, XS), take#(X1, mark 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#(mark X1, X2) -> take#(X1, X2)) (active# take(s N, cons(X, XS)) -> take#(N, XS), take#(active X1, X2) -> take#(X1, X2)) (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)) (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#(mark X1, X2) -> pair#(X1, X2), pair#(active 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)) (pair#(X1, mark X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)) (zip#(mark X1, X2) -> zip#(X1, X2), zip#(X1, mark 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#(mark X1, X2) -> zip#(X1, X2)) (zip#(mark 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#(X1, active 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)) (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#(mark X1, X2) -> take#(X1, X2), take#(active 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)) (take#(X1, mark X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(X1, mark 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#(mark X1, X2) -> cons#(X1, X2)) (cons#(mark 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#(X1, active 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)) (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) (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)) (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) (mark# tail X -> active# tail 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) -> cons#(s X, incr XS)) (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) -> s# X) (mark# tail X -> active# tail mark X, active# take(0(), XS) -> mark# nil()) (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(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (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# zip(X, nil()) -> mark# nil()) (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(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)) -> zip#(XS, YS)) (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(nil(), XS) -> mark# nil()) (mark# tail X -> active# tail mark X, active# tail cons(X, XS) -> mark# 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# repItems cons(X, XS) -> cons#(X, cons(X, 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) -> repItems# XS) (mark# tail X -> active# tail mark X, active# repItems nil() -> mark# nil()) (mark# incr X -> active# 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) -> cons#(s X, incr XS)) (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) -> s# X) (mark# incr X -> active# incr mark X, active# take(0(), XS) -> mark# nil()) (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(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (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# zip(X, nil()) -> mark# nil()) (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(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)) -> zip#(XS, YS)) (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(nil(), XS) -> mark# nil()) (mark# incr X -> active# incr mark X, active# tail cons(X, XS) -> mark# 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# repItems cons(X, XS) -> cons#(X, cons(X, 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) -> repItems# XS) (mark# incr X -> active# incr mark X, active# repItems nil() -> mark# nil()) (mark# tail X -> tail# mark X, tail# mark X -> tail# X) (mark# tail X -> tail# mark X, tail# active X -> tail# X) (mark# incr X -> incr# mark X, incr# mark X -> incr# X) (mark# incr X -> incr# mark X, incr# active X -> incr# 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)) } STATUS: arrows: 0.875469 SCCS (9): 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: { 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: { repItems# mark X -> repItems# X, repItems# active X -> repItems# X} Scc: { tail# mark X -> tail# X, tail# active X -> tail# X} 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 (28): 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} Open SCC (4): 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} Open SCC (4): 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} Open SCC (4): 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} Open SCC (2): 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} Open SCC (2): 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} Open SCC (2): 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} Open SCC (2): 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} Open SCC (4): 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} Open