MAYBE Time: 2.527486 TRS: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} DP: DP: { cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2), incr# mark X -> incr# X, incr# ok X -> incr# X, active# cons(X1, X2) -> cons#(active X1, X2), active# cons(X1, X2) -> active# X1, active# incr X -> incr# active X, active# incr X -> active# X, 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() -> incr# pairNs(), active# pairNs() -> cons#(0(), incr oddNs()), active# pairNs() -> incr# oddNs(), active# s X -> active# X, active# s X -> s# active X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2), active# take(X1, X2) -> take#(active X1, X2), active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS)), active# take(s N, cons(X, XS)) -> take#(N, XS), active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(X1, active X2), active# zip(X1, X2) -> zip#(active X1, X2), 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# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2), active# pair(X1, X2) -> pair#(active X1, X2), active# tail X -> active# X, active# tail X -> tail# active X, active# repItems X -> active# X, active# repItems X -> repItems# active X, 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, s# mark X -> s# X, s# ok X -> s# X, take#(X1, mark X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2), zip#(X1, mark X2) -> zip#(X1, X2), zip#(mark X1, X2) -> zip#(X1, X2), zip#(ok X1, ok X2) -> zip#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2), tail# mark X -> tail# X, tail# ok X -> tail# X, repItems# mark X -> repItems# X, repItems# ok X -> repItems# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2), proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> incr# proper X, proper# incr X -> proper# X, proper# s X -> s# proper X, proper# s X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2), proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> zip#(proper X1, proper X2), proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2), proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2, proper# tail X -> tail# proper X, proper# tail X -> proper# X, proper# repItems X -> repItems# proper X, proper# repItems X -> proper# X, top# mark X -> proper# X, top# mark X -> top# proper X, top# ok X -> active# X, top# ok X -> top# active X} TRS: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} UR: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X} EDG: { (active# take(X1, X2) -> active# X1, active# repItems cons(X, XS) -> repItems# XS) (active# take(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# take(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# take(X1, X2) -> active# X1, active# repItems X -> repItems# active X) (active# take(X1, X2) -> active# X1, active# repItems X -> active# X) (active# take(X1, X2) -> active# X1, active# tail X -> tail# active X) (active# take(X1, X2) -> active# X1, active# tail X -> active# X) (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2)) (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2)) (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2) (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# take(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# take(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# take(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(active X1, X2)) (active# take(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(X1, active X2)) (active# take(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2) (active# take(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# take(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2)) (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2)) (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2) (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X1, active# s X -> s# active X) (active# take(X1, X2) -> active# X1, active# s X -> active# X) (active# take(X1, X2) -> active# X1, active# pairNs() -> incr# oddNs()) (active# take(X1, X2) -> active# X1, active# pairNs() -> cons#(0(), incr oddNs())) (active# take(X1, X2) -> active# X1, active# oddNs() -> incr# pairNs()) (active# take(X1, X2) -> active# X1, active# incr cons(X, XS) -> s# X) (active# take(X1, X2) -> active# X1, active# incr cons(X, XS) -> incr# XS) (active# take(X1, X2) -> active# X1, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# take(X1, X2) -> active# X1, active# incr X -> active# X) (active# take(X1, X2) -> active# X1, active# incr X -> incr# active X) (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2)) (active# pair(X1, X2) -> active# X1, active# repItems cons(X, XS) -> repItems# XS) (active# pair(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# pair(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# pair(X1, X2) -> active# X1, active# repItems X -> repItems# active X) (active# pair(X1, X2) -> active# X1, active# repItems X -> active# X) (active# pair(X1, X2) -> active# X1, active# tail X -> tail# active X) (active# pair(X1, X2) -> active# X1, active# tail X -> active# X) (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2)) (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2)) (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2) (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# pair(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# pair(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# pair(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(active X1, X2)) (active# pair(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(X1, active X2)) (active# pair(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2) (active# pair(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# pair(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2)) (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2)) (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2) (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X1, active# s X -> s# active X) (active# pair(X1, X2) -> active# X1, active# s X -> active# X) (active# pair(X1, X2) -> active# X1, active# pairNs() -> incr# oddNs()) (active# pair(X1, X2) -> active# X1, active# pairNs() -> cons#(0(), incr oddNs())) (active# pair(X1, X2) -> active# X1, active# oddNs() -> incr# pairNs()) (active# pair(X1, X2) -> active# X1, active# incr cons(X, XS) -> s# X) (active# pair(X1, X2) -> active# X1, active# incr cons(X, XS) -> incr# XS) (active# pair(X1, X2) -> active# X1, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# pair(X1, X2) -> active# X1, active# incr X -> active# X) (active# pair(X1, X2) -> active# X1, active# incr X -> incr# active X) (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2)) (proper# take(X1, X2) -> proper# X1, proper# repItems X -> proper# X) (proper# take(X1, X2) -> proper# X1, proper# repItems X -> repItems# proper X) (proper# take(X1, X2) -> proper# X1, proper# tail X -> proper# X) (proper# take(X1, X2) -> proper# X1, proper# tail X -> tail# proper X) (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X1, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X1, proper# s X -> proper# X) (proper# take(X1, X2) -> proper# X1, proper# s X -> s# proper X) (proper# take(X1, X2) -> proper# X1, proper# incr X -> proper# X) (proper# take(X1, X2) -> proper# X1, proper# incr X -> incr# proper X) (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X1, proper# repItems X -> proper# X) (proper# pair(X1, X2) -> proper# X1, proper# repItems X -> repItems# proper X) (proper# pair(X1, X2) -> proper# X1, proper# tail X -> proper# X) (proper# pair(X1, X2) -> proper# X1, proper# tail X -> tail# proper X) (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X1, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X1, proper# s X -> proper# X) (proper# pair(X1, X2) -> proper# X1, proper# s X -> s# proper X) (proper# pair(X1, X2) -> proper# X1, proper# incr X -> proper# X) (proper# pair(X1, X2) -> proper# X1, proper# incr X -> incr# proper X) (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (active# repItems cons(X, XS) -> repItems# XS, repItems# ok X -> repItems# X) (active# repItems cons(X, XS) -> repItems# XS, repItems# mark X -> repItems# X) (incr# mark X -> incr# X, incr# ok X -> incr# X) (incr# mark X -> incr# X, incr# mark X -> incr# X) (active# incr X -> active# X, active# repItems cons(X, XS) -> repItems# XS) (active# incr X -> active# X, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# incr X -> active# X, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# incr X -> active# X, active# repItems X -> repItems# active X) (active# incr X -> active# X, active# repItems X -> active# X) (active# incr X -> active# X, active# tail X -> tail# active X) (active# incr X -> active# X, active# tail X -> active# X) (active# incr X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2)) (active# incr X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2)) (active# incr X -> active# X, active# pair(X1, X2) -> active# X2) (active# incr X -> active# X, active# pair(X1, X2) -> active# X1) (active# incr X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# incr X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# incr X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# incr X -> active# X, active# zip(X1, X2) -> zip#(active X1, X2)) (active# incr X -> active# X, active# zip(X1, X2) -> zip#(X1, active X2)) (active# incr X -> active# X, active# zip(X1, X2) -> active# X2) (active# incr X -> active# X, active# zip(X1, X2) -> active# X1) (active# incr X -> active# X, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# incr X -> active# X, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# incr X -> active# X, active# take(X1, X2) -> take#(active X1, X2)) (active# incr X -> active# X, active# take(X1, X2) -> take#(X1, active X2)) (active# incr X -> active# X, active# take(X1, X2) -> active# X2) (active# incr X -> active# X, active# take(X1, X2) -> active# X1) (active# incr X -> active# X, active# s X -> s# active X) (active# incr X -> active# X, active# s X -> active# X) (active# incr X -> active# X, active# pairNs() -> incr# oddNs()) (active# incr X -> active# X, active# pairNs() -> cons#(0(), incr oddNs())) (active# incr X -> active# X, active# oddNs() -> incr# pairNs()) (active# incr X -> active# X, active# incr cons(X, XS) -> s# X) (active# incr X -> active# X, active# incr cons(X, XS) -> incr# XS) (active# incr X -> active# X, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# incr X -> active# X, active# incr X -> active# X) (active# incr X -> active# X, active# incr X -> incr# active X) (active# incr X -> active# X, active# cons(X1, X2) -> active# X1) (active# incr X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2)) (active# s X -> active# X, active# repItems cons(X, XS) -> repItems# XS) (active# s X -> active# X, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# s X -> active# X, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# s X -> active# X, active# repItems X -> repItems# active X) (active# s X -> active# X, active# repItems X -> active# X) (active# s X -> active# X, active# tail X -> tail# active X) (active# s X -> active# X, active# tail X -> active# X) (active# s X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2)) (active# s X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2)) (active# s X -> active# X, active# pair(X1, X2) -> active# X2) (active# s X -> active# X, active# pair(X1, X2) -> active# X1) (active# s X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# s X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# s X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# s X -> active# X, active# zip(X1, X2) -> zip#(active X1, X2)) (active# s X -> active# X, active# zip(X1, X2) -> zip#(X1, active X2)) (active# s X -> active# X, active# zip(X1, X2) -> active# X2) (active# s X -> active# X, active# zip(X1, X2) -> active# X1) (active# s X -> active# X, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# s X -> active# X, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# s X -> active# X, active# take(X1, X2) -> take#(active X1, X2)) (active# s X -> active# X, active# take(X1, X2) -> take#(X1, active X2)) (active# s X -> active# X, active# take(X1, X2) -> active# X2) (active# s X -> active# X, active# take(X1, X2) -> active# X1) (active# s X -> active# X, active# s X -> s# active X) (active# s X -> active# X, active# s X -> active# X) (active# s X -> active# X, active# pairNs() -> incr# oddNs()) (active# s X -> active# X, active# pairNs() -> cons#(0(), incr oddNs())) (active# s X -> active# X, active# oddNs() -> incr# pairNs()) (active# s X -> active# X, active# incr cons(X, XS) -> s# X) (active# s X -> active# X, active# incr cons(X, XS) -> incr# XS) (active# s X -> active# X, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# s X -> active# X, active# incr X -> active# X) (active# s X -> active# X, active# incr X -> incr# active X) (active# s X -> active# X, active# cons(X1, X2) -> active# X1) (active# s X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2)) (active# repItems X -> active# X, active# repItems cons(X, XS) -> repItems# XS) (active# repItems X -> active# X, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# repItems X -> active# X, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# repItems X -> active# X, active# repItems X -> repItems# active X) (active# repItems X -> active# X, active# repItems X -> active# X) (active# repItems X -> active# X, active# tail X -> tail# active X) (active# repItems X -> active# X, active# tail X -> active# X) (active# repItems X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2)) (active# repItems X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2)) (active# repItems X -> active# X, active# pair(X1, X2) -> active# X2) (active# repItems X -> active# X, active# pair(X1, X2) -> active# X1) (active# repItems X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# repItems X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# repItems X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# repItems X -> active# X, active# zip(X1, X2) -> zip#(active X1, X2)) (active# repItems X -> active# X, active# zip(X1, X2) -> zip#(X1, active X2)) (active# repItems X -> active# X, active# zip(X1, X2) -> active# X2) (active# repItems X -> active# X, active# zip(X1, X2) -> active# X1) (active# repItems X -> active# X, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# repItems X -> active# X, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# repItems X -> active# X, active# take(X1, X2) -> take#(active X1, X2)) (active# repItems X -> active# X, active# take(X1, X2) -> take#(X1, active X2)) (active# repItems X -> active# X, active# take(X1, X2) -> active# X2) (active# repItems X -> active# X, active# take(X1, X2) -> active# X1) (active# repItems X -> active# X, active# s X -> s# active X) (active# repItems X -> active# X, active# s X -> active# X) (active# repItems X -> active# X, active# pairNs() -> incr# oddNs()) (active# repItems X -> active# X, active# pairNs() -> cons#(0(), incr oddNs())) (active# repItems X -> active# X, active# oddNs() -> incr# pairNs()) (active# repItems X -> active# X, active# incr cons(X, XS) -> s# X) (active# repItems X -> active# X, active# incr cons(X, XS) -> incr# XS) (active# repItems X -> active# X, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# repItems X -> active# X, active# incr X -> active# X) (active# repItems X -> active# X, active# incr X -> incr# active X) (active# repItems X -> active# X, active# cons(X1, X2) -> active# X1) (active# repItems X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2)) (s# ok X -> s# X, s# ok X -> s# X) (s# ok X -> s# X, s# mark X -> s# X) (tail# ok X -> tail# X, tail# ok X -> tail# X) (tail# ok X -> tail# X, tail# mark X -> tail# X) (repItems# ok X -> repItems# X, repItems# ok X -> repItems# X) (repItems# ok X -> repItems# X, repItems# mark X -> repItems# X) (proper# s X -> proper# X, proper# repItems X -> proper# X) (proper# s X -> proper# X, proper# repItems X -> repItems# proper X) (proper# s X -> proper# X, proper# tail X -> proper# X) (proper# s X -> proper# X, proper# tail X -> tail# proper X) (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X2) (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X1) (proper# s X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# s X -> proper# X, proper# zip(X1, X2) -> proper# X2) (proper# s X -> proper# X, proper# zip(X1, X2) -> proper# X1) (proper# s X -> proper# X, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X2) (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1) (proper# s X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# s X -> proper# X, proper# s X -> proper# X) (proper# s X -> proper# X, proper# s X -> s# proper X) (proper# s X -> proper# X, proper# incr X -> proper# X) (proper# s X -> proper# X, proper# incr X -> incr# proper X) (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2) (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1) (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# repItems X -> proper# X, proper# repItems X -> proper# X) (proper# repItems X -> proper# X, proper# repItems X -> repItems# proper X) (proper# repItems X -> proper# X, proper# tail X -> proper# X) (proper# repItems X -> proper# X, proper# tail X -> tail# proper X) (proper# repItems X -> proper# X, proper# pair(X1, X2) -> proper# X2) (proper# repItems X -> proper# X, proper# pair(X1, X2) -> proper# X1) (proper# repItems X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# repItems X -> proper# X, proper# zip(X1, X2) -> proper# X2) (proper# repItems X -> proper# X, proper# zip(X1, X2) -> proper# X1) (proper# repItems X -> proper# X, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# repItems X -> proper# X, proper# take(X1, X2) -> proper# X2) (proper# repItems X -> proper# X, proper# take(X1, X2) -> proper# X1) (proper# repItems X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# repItems X -> proper# X, proper# s X -> proper# X) (proper# repItems X -> proper# X, proper# s X -> s# proper X) (proper# repItems X -> proper# X, proper# incr X -> proper# X) (proper# repItems X -> proper# X, proper# incr X -> incr# proper X) (proper# repItems X -> proper# X, proper# cons(X1, X2) -> proper# X2) (proper# repItems X -> proper# X, proper# cons(X1, X2) -> proper# X1) (proper# repItems X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (top# ok X -> active# X, active# repItems cons(X, XS) -> repItems# XS) (top# ok X -> active# X, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (top# ok X -> active# X, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (top# ok X -> active# X, active# repItems X -> repItems# active X) (top# ok X -> active# X, active# repItems X -> active# X) (top# ok X -> active# X, active# tail X -> tail# active X) (top# ok X -> active# X, active# tail X -> active# X) (top# ok X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2)) (top# ok X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2)) (top# ok X -> active# X, active# pair(X1, X2) -> active# X2) (top# ok X -> active# X, active# pair(X1, X2) -> active# X1) (top# ok X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (top# ok X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (top# ok X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (top# ok X -> active# X, active# zip(X1, X2) -> zip#(active X1, X2)) (top# ok X -> active# X, active# zip(X1, X2) -> zip#(X1, active X2)) (top# ok X -> active# X, active# zip(X1, X2) -> active# X2) (top# ok X -> active# X, active# zip(X1, X2) -> active# X1) (top# ok X -> active# X, active# take(s N, cons(X, XS)) -> take#(N, XS)) (top# ok X -> active# X, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (top# ok X -> active# X, active# take(X1, X2) -> take#(active X1, X2)) (top# ok X -> active# X, active# take(X1, X2) -> take#(X1, active X2)) (top# ok X -> active# X, active# take(X1, X2) -> active# X2) (top# ok X -> active# X, active# take(X1, X2) -> active# X1) (top# ok X -> active# X, active# s X -> s# active X) (top# ok X -> active# X, active# s X -> active# X) (top# ok X -> active# X, active# pairNs() -> incr# oddNs()) (top# ok X -> active# X, active# pairNs() -> cons#(0(), incr oddNs())) (top# ok X -> active# X, active# oddNs() -> incr# pairNs()) (top# ok X -> active# X, active# incr cons(X, XS) -> s# X) (top# ok X -> active# X, active# incr cons(X, XS) -> incr# XS) (top# ok X -> active# X, active# incr cons(X, XS) -> cons#(s X, incr XS)) (top# ok X -> active# X, active# incr X -> active# X) (top# ok X -> active# X, active# incr X -> incr# active X) (top# ok X -> active# X, active# cons(X1, X2) -> active# X1) (top# ok X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2)) (active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS), zip#(ok X1, ok 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, mark X2) -> zip#(X1, X2)) (active# take(X1, X2) -> take#(X1, active X2), take#(ok X1, ok X2) -> take#(X1, X2)) (active# take(X1, X2) -> take#(X1, active X2), take#(X1, mark X2) -> take#(X1, X2)) (active# pair(X1, X2) -> pair#(X1, active X2), pair#(ok X1, ok X2) -> pair#(X1, X2)) (active# pair(X1, X2) -> pair#(X1, active X2), pair#(X1, mark X2) -> pair#(X1, X2)) (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2)) (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(mark X1, X2) -> cons#(X1, X2)) (proper# zip(X1, X2) -> zip#(proper X1, proper X2), zip#(ok X1, ok X2) -> zip#(X1, X2)) (proper# zip(X1, X2) -> zip#(proper X1, proper X2), zip#(mark X1, X2) -> zip#(X1, X2)) (proper# zip(X1, X2) -> zip#(proper X1, proper X2), zip#(X1, mark X2) -> zip#(X1, X2)) (active# incr X -> incr# active X, incr# ok X -> incr# X) (active# incr X -> incr# active X, incr# mark X -> incr# X) (active# tail X -> tail# active X, tail# ok X -> tail# X) (active# tail X -> tail# active X, tail# mark X -> tail# X) (proper# incr X -> incr# proper X, incr# ok X -> incr# X) (proper# incr X -> incr# proper X, incr# mark X -> incr# X) (proper# tail X -> tail# proper X, tail# ok X -> tail# X) (proper# tail X -> tail# proper X, tail# mark X -> tail# X) (top# mark X -> top# proper X, top# ok X -> top# active X) (top# mark X -> top# proper X, top# ok X -> active# X) (top# mark X -> top# proper X, top# mark X -> top# proper X) (top# mark X -> top# proper X, top# mark X -> proper# X) (active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y), pair#(ok X1, ok X2) -> pair#(X1, X2)) (active# zip(X1, X2) -> active# X2, active# repItems cons(X, XS) -> repItems# XS) (active# zip(X1, X2) -> active# X2, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# zip(X1, X2) -> active# X2, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# zip(X1, X2) -> active# X2, active# repItems X -> repItems# active X) (active# zip(X1, X2) -> active# X2, active# repItems X -> active# X) (active# zip(X1, X2) -> active# X2, active# tail X -> tail# active X) (active# zip(X1, X2) -> active# X2, active# tail X -> active# X) (active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2)) (active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2)) (active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2) (active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# zip(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# zip(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# zip(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(active X1, X2)) (active# zip(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(X1, active X2)) (active# zip(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X2) (active# zip(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X2, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# zip(X1, X2) -> active# X2, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# zip(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2)) (active# zip(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2)) (active# zip(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2) (active# zip(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X2, active# s X -> s# active X) (active# zip(X1, X2) -> active# X2, active# s X -> active# X) (active# zip(X1, X2) -> active# X2, active# pairNs() -> incr# oddNs()) (active# zip(X1, X2) -> active# X2, active# pairNs() -> cons#(0(), incr oddNs())) (active# zip(X1, X2) -> active# X2, active# oddNs() -> incr# pairNs()) (active# zip(X1, X2) -> active# X2, active# incr cons(X, XS) -> s# X) (active# zip(X1, X2) -> active# X2, active# incr cons(X, XS) -> incr# XS) (active# zip(X1, X2) -> active# X2, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# zip(X1, X2) -> active# X2, active# incr X -> active# X) (active# zip(X1, X2) -> active# X2, active# incr X -> incr# active X) (active# zip(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2)) (proper# cons(X1, X2) -> proper# X2, proper# repItems X -> proper# X) (proper# cons(X1, X2) -> proper# X2, proper# repItems X -> repItems# proper X) (proper# cons(X1, X2) -> proper# X2, proper# tail X -> proper# X) (proper# cons(X1, X2) -> proper# X2, proper# tail X -> tail# proper X) (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X2, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X) (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X) (proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X) (proper# cons(X1, X2) -> proper# X2, proper# incr X -> incr# proper X) (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X2, proper# repItems X -> proper# X) (proper# zip(X1, X2) -> proper# X2, proper# repItems X -> repItems# proper X) (proper# zip(X1, X2) -> proper# X2, proper# tail X -> proper# X) (proper# zip(X1, X2) -> proper# X2, proper# tail X -> tail# proper X) (proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X2, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X2, proper# s X -> proper# X) (proper# zip(X1, X2) -> proper# X2, proper# s X -> s# proper X) (proper# zip(X1, X2) -> proper# X2, proper# incr X -> proper# X) (proper# zip(X1, X2) -> proper# X2, proper# incr X -> incr# proper X) (proper# zip(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (active# cons(X1, X2) -> cons#(active X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2)) (active# cons(X1, X2) -> cons#(active X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (active# zip(X1, X2) -> zip#(active X1, X2), zip#(ok X1, ok X2) -> zip#(X1, X2)) (active# zip(X1, X2) -> zip#(active X1, X2), zip#(mark X1, X2) -> zip#(X1, X2)) (active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS)), cons#(ok X1, ok X2) -> cons#(X1, X2)) (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2)) (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (take#(mark X1, X2) -> take#(X1, X2), take#(ok X1, ok 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, mark X2) -> take#(X1, X2)) (zip#(X1, mark X2) -> zip#(X1, X2), zip#(ok X1, ok 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, mark X2) -> zip#(X1, X2)) (zip#(ok X1, ok X2) -> zip#(X1, X2), zip#(ok X1, ok X2) -> zip#(X1, X2)) (zip#(ok X1, ok X2) -> zip#(X1, X2), zip#(mark X1, X2) -> zip#(X1, X2)) (zip#(ok X1, ok X2) -> zip#(X1, X2), zip#(X1, mark X2) -> zip#(X1, X2)) (pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok 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, mark X2) -> pair#(X1, X2)) (active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS)), cons#(ok X1, ok 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#(ok X1, ok X2) -> cons#(X1, X2)) (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2)) (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2)) (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(mark X1, X2) -> pair#(X1, X2)) (pair#(X1, mark X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(mark X1, X2) -> zip#(X1, X2)) (zip#(mark X1, X2) -> zip#(X1, X2), zip#(ok X1, ok X2) -> zip#(X1, X2)) (take#(ok X1, ok X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (take#(ok X1, ok X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2)) (take#(ok X1, ok X2) -> take#(X1, X2), take#(ok X1, ok 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#(mark X1, X2) -> take#(X1, X2)) (take#(X1, mark X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2)) (active# pair(X1, X2) -> pair#(active X1, X2), pair#(mark X1, X2) -> pair#(X1, X2)) (active# pair(X1, X2) -> pair#(active X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2)) (active# take(X1, X2) -> take#(active X1, X2), take#(mark X1, X2) -> take#(X1, X2)) (active# take(X1, X2) -> take#(active X1, X2), take#(ok X1, ok X2) -> take#(X1, X2)) (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X2, proper# incr X -> incr# proper X) (proper# pair(X1, X2) -> proper# X2, proper# incr X -> proper# X) (proper# pair(X1, X2) -> proper# X2, proper# s X -> s# proper X) (proper# pair(X1, X2) -> proper# X2, proper# s X -> proper# X) (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X2, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1) (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2) (proper# pair(X1, X2) -> proper# X2, proper# tail X -> tail# proper X) (proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X) (proper# pair(X1, X2) -> proper# X2, proper# repItems X -> repItems# proper X) (proper# pair(X1, X2) -> proper# X2, proper# repItems X -> proper# X) (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X2, proper# incr X -> incr# proper X) (proper# take(X1, X2) -> proper# X2, proper# incr X -> proper# X) (proper# take(X1, X2) -> proper# X2, proper# s X -> s# proper X) (proper# take(X1, X2) -> proper# X2, proper# s X -> proper# X) (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1) (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2) (proper# take(X1, X2) -> proper# X2, proper# tail X -> tail# proper X) (proper# take(X1, X2) -> proper# X2, proper# tail X -> proper# X) (proper# take(X1, X2) -> proper# X2, proper# repItems X -> repItems# proper X) (proper# take(X1, X2) -> proper# X2, proper# repItems X -> proper# X) (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2)) (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X2, active# incr X -> incr# active X) (active# pair(X1, X2) -> active# X2, active# incr X -> active# X) (active# pair(X1, X2) -> active# X2, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# pair(X1, X2) -> active# X2, active# incr cons(X, XS) -> incr# XS) (active# pair(X1, X2) -> active# X2, active# incr cons(X, XS) -> s# X) (active# pair(X1, X2) -> active# X2, active# oddNs() -> incr# pairNs()) (active# pair(X1, X2) -> active# X2, active# pairNs() -> cons#(0(), incr oddNs())) (active# pair(X1, X2) -> active# X2, active# pairNs() -> incr# oddNs()) (active# pair(X1, X2) -> active# X2, active# s X -> active# X) (active# pair(X1, X2) -> active# X2, active# s X -> s# active X) (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2) (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2)) (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2)) (active# pair(X1, X2) -> active# X2, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# pair(X1, X2) -> active# X2, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# pair(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X2) (active# pair(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(X1, active X2)) (active# pair(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(active X1, X2)) (active# pair(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# pair(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# pair(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1) (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2) (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2)) (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2)) (active# pair(X1, X2) -> active# X2, active# tail X -> active# X) (active# pair(X1, X2) -> active# X2, active# tail X -> tail# active X) (active# pair(X1, X2) -> active# X2, active# repItems X -> active# X) (active# pair(X1, X2) -> active# X2, active# repItems X -> repItems# active X) (active# pair(X1, X2) -> active# X2, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# pair(X1, X2) -> active# X2, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# pair(X1, X2) -> active# X2, active# repItems cons(X, XS) -> repItems# XS) (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2)) (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X2, active# incr X -> incr# active X) (active# take(X1, X2) -> active# X2, active# incr X -> active# X) (active# take(X1, X2) -> active# X2, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# take(X1, X2) -> active# X2, active# incr cons(X, XS) -> incr# XS) (active# take(X1, X2) -> active# X2, active# incr cons(X, XS) -> s# X) (active# take(X1, X2) -> active# X2, active# oddNs() -> incr# pairNs()) (active# take(X1, X2) -> active# X2, active# pairNs() -> cons#(0(), incr oddNs())) (active# take(X1, X2) -> active# X2, active# pairNs() -> incr# oddNs()) (active# take(X1, X2) -> active# X2, active# s X -> active# X) (active# take(X1, X2) -> active# X2, active# s X -> s# active X) (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2) (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2)) (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2)) (active# take(X1, X2) -> active# X2, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# take(X1, X2) -> active# X2, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X2) (active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(X1, active X2)) (active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> zip#(active X1, X2)) (active# take(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# take(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# take(X1, X2) -> active# X2, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1) (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2) (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2)) (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2)) (active# take(X1, X2) -> active# X2, active# tail X -> active# X) (active# take(X1, X2) -> active# X2, active# tail X -> tail# active X) (active# take(X1, X2) -> active# X2, active# repItems X -> active# X) (active# take(X1, X2) -> active# X2, active# repItems X -> repItems# active X) (active# take(X1, X2) -> active# X2, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# take(X1, X2) -> active# X2, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# take(X1, X2) -> active# X2, active# repItems cons(X, XS) -> repItems# XS) (top# ok X -> top# active X, top# mark X -> proper# X) (top# ok X -> top# active X, top# mark X -> top# proper X) (top# ok X -> top# active X, top# ok X -> active# X) (top# ok X -> top# active X, top# ok X -> top# active X) (proper# repItems X -> repItems# proper X, repItems# mark X -> repItems# X) (proper# repItems X -> repItems# proper X, repItems# ok X -> repItems# X) (proper# s X -> s# proper X, s# mark X -> s# X) (proper# s X -> s# proper X, s# ok X -> s# X) (active# repItems X -> repItems# active X, repItems# mark X -> repItems# X) (active# repItems X -> repItems# active X, repItems# ok X -> repItems# X) (active# s X -> s# active X, s# mark X -> s# X) (active# s X -> s# active X, s# ok X -> s# X) (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(X1, mark X2) -> pair#(X1, X2)) (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(mark X1, X2) -> pair#(X1, X2)) (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(ok X1, ok X2) -> pair#(X1, X2)) (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(X1, mark X2) -> take#(X1, X2)) (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(mark X1, X2) -> take#(X1, X2)) (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(ok X1, ok X2) -> take#(X1, X2)) (active# repItems cons(X, XS) -> cons#(X, repItems XS), cons#(ok X1, ok X2) -> cons#(X1, X2)) (active# zip(X1, X2) -> zip#(X1, active X2), zip#(X1, mark X2) -> zip#(X1, X2)) (active# zip(X1, X2) -> zip#(X1, active X2), zip#(ok X1, ok X2) -> zip#(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#(ok X1, ok X2) -> cons#(X1, X2)) (active# take(s N, cons(X, XS)) -> take#(N, XS), take#(X1, mark X2) -> take#(X1, X2)) (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1) (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2) (top# mark X -> proper# X, proper# incr X -> incr# proper X) (top# mark X -> proper# X, proper# incr X -> proper# X) (top# mark X -> proper# X, proper# s X -> s# proper X) (top# mark X -> proper# X, proper# s X -> proper# X) (top# mark X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2)) (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X1) (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X2) (top# mark X -> proper# X, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (top# mark X -> proper# X, proper# zip(X1, X2) -> proper# X1) (top# mark X -> proper# X, proper# zip(X1, X2) -> proper# X2) (top# mark X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X1) (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X2) (top# mark X -> proper# X, proper# tail X -> tail# proper X) (top# mark X -> proper# X, proper# tail X -> proper# X) (top# mark X -> proper# X, proper# repItems X -> repItems# proper X) (top# mark X -> proper# X, proper# repItems X -> proper# X) (proper# tail X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X1) (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X2) (proper# tail X -> proper# X, proper# incr X -> incr# proper X) (proper# tail X -> proper# X, proper# incr X -> proper# X) (proper# tail X -> proper# X, proper# s X -> s# proper X) (proper# tail X -> proper# X, proper# s X -> proper# X) (proper# tail X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X1) (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X2) (proper# tail X -> proper# X, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# tail X -> proper# X, proper# zip(X1, X2) -> proper# X1) (proper# tail X -> proper# X, proper# zip(X1, X2) -> proper# X2) (proper# tail X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X1) (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X2) (proper# tail X -> proper# X, proper# tail X -> tail# proper X) (proper# tail X -> proper# X, proper# tail X -> proper# X) (proper# tail X -> proper# X, proper# repItems X -> repItems# proper X) (proper# tail X -> proper# X, proper# repItems X -> proper# X) (proper# incr X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# incr X -> proper# X, proper# cons(X1, X2) -> proper# X1) (proper# incr X -> proper# X, proper# cons(X1, X2) -> proper# X2) (proper# incr X -> proper# X, proper# incr X -> incr# proper X) (proper# incr X -> proper# X, proper# incr X -> proper# X) (proper# incr X -> proper# X, proper# s X -> s# proper X) (proper# incr X -> proper# X, proper# s X -> proper# X) (proper# incr X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# incr X -> proper# X, proper# take(X1, X2) -> proper# X1) (proper# incr X -> proper# X, proper# take(X1, X2) -> proper# X2) (proper# incr X -> proper# X, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# incr X -> proper# X, proper# zip(X1, X2) -> proper# X1) (proper# incr X -> proper# X, proper# zip(X1, X2) -> proper# X2) (proper# incr X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# incr X -> proper# X, proper# pair(X1, X2) -> proper# X1) (proper# incr X -> proper# X, proper# pair(X1, X2) -> proper# X2) (proper# incr X -> proper# X, proper# tail X -> tail# proper X) (proper# incr X -> proper# X, proper# tail X -> proper# X) (proper# incr X -> proper# X, proper# repItems X -> repItems# proper X) (proper# incr X -> proper# X, proper# repItems X -> proper# X) (repItems# mark X -> repItems# X, repItems# mark X -> repItems# X) (repItems# mark X -> repItems# X, repItems# ok X -> repItems# X) (tail# mark X -> tail# X, tail# mark X -> tail# X) (tail# mark X -> tail# X, tail# ok X -> tail# X) (s# mark X -> s# X, s# mark X -> s# X) (s# mark X -> s# X, s# ok X -> s# X) (active# tail X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2)) (active# tail X -> active# X, active# cons(X1, X2) -> active# X1) (active# tail X -> active# X, active# incr X -> incr# active X) (active# tail X -> active# X, active# incr X -> active# X) (active# tail X -> active# X, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# tail X -> active# X, active# incr cons(X, XS) -> incr# XS) (active# tail X -> active# X, active# incr cons(X, XS) -> s# X) (active# tail X -> active# X, active# oddNs() -> incr# pairNs()) (active# tail X -> active# X, active# pairNs() -> cons#(0(), incr oddNs())) (active# tail X -> active# X, active# pairNs() -> incr# oddNs()) (active# tail X -> active# X, active# s X -> active# X) (active# tail X -> active# X, active# s X -> s# active X) (active# tail X -> active# X, active# take(X1, X2) -> active# X1) (active# tail X -> active# X, active# take(X1, X2) -> active# X2) (active# tail X -> active# X, active# take(X1, X2) -> take#(X1, active X2)) (active# tail X -> active# X, active# take(X1, X2) -> take#(active X1, X2)) (active# tail X -> active# X, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# tail X -> active# X, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# tail X -> active# X, active# zip(X1, X2) -> active# X1) (active# tail X -> active# X, active# zip(X1, X2) -> active# X2) (active# tail X -> active# X, active# zip(X1, X2) -> zip#(X1, active X2)) (active# tail X -> active# X, active# zip(X1, X2) -> zip#(active X1, X2)) (active# tail X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# tail X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# tail X -> active# X, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# tail X -> active# X, active# pair(X1, X2) -> active# X1) (active# tail X -> active# X, active# pair(X1, X2) -> active# X2) (active# tail X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2)) (active# tail X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2)) (active# tail X -> active# X, active# tail X -> active# X) (active# tail X -> active# X, active# tail X -> tail# active X) (active# tail X -> active# X, active# repItems X -> active# X) (active# tail X -> active# X, active# repItems X -> repItems# active X) (active# tail X -> active# X, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# tail X -> active# X, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# tail X -> active# X, active# repItems cons(X, XS) -> repItems# XS) (active# incr cons(X, XS) -> s# X, s# ok X -> s# X) (incr# ok X -> incr# X, incr# mark X -> incr# X) (incr# ok X -> incr# X, incr# ok X -> incr# X) (active# incr cons(X, XS) -> incr# XS, incr# mark X -> incr# X) (active# incr cons(X, XS) -> incr# XS, incr# ok X -> incr# X) (proper# zip(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X1, proper# incr X -> incr# proper X) (proper# zip(X1, X2) -> proper# X1, proper# incr X -> proper# X) (proper# zip(X1, X2) -> proper# X1, proper# s X -> s# proper X) (proper# zip(X1, X2) -> proper# X1, proper# s X -> proper# X) (proper# zip(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# zip(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1) (proper# zip(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2) (proper# zip(X1, X2) -> proper# X1, proper# tail X -> tail# proper X) (proper# zip(X1, X2) -> proper# X1, proper# tail X -> proper# X) (proper# zip(X1, X2) -> proper# X1, proper# repItems X -> repItems# proper X) (proper# zip(X1, X2) -> proper# X1, proper# repItems X -> proper# X) (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X1, proper# incr X -> incr# proper X) (proper# cons(X1, X2) -> proper# X1, proper# incr X -> proper# X) (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X) (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X) (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X1, proper# zip(X1, X2) -> zip#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2)) (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1) (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2) (proper# cons(X1, X2) -> proper# X1, proper# tail X -> tail# proper X) (proper# cons(X1, X2) -> proper# X1, proper# tail X -> proper# X) (proper# cons(X1, X2) -> proper# X1, proper# repItems X -> repItems# proper X) (proper# cons(X1, X2) -> proper# X1, proper# repItems X -> proper# X) (active# zip(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2)) (active# zip(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X1, active# incr X -> incr# active X) (active# zip(X1, X2) -> active# X1, active# incr X -> active# X) (active# zip(X1, X2) -> active# X1, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# zip(X1, X2) -> active# X1, active# incr cons(X, XS) -> incr# XS) (active# zip(X1, X2) -> active# X1, active# incr cons(X, XS) -> s# X) (active# zip(X1, X2) -> active# X1, active# oddNs() -> incr# pairNs()) (active# zip(X1, X2) -> active# X1, active# pairNs() -> cons#(0(), incr oddNs())) (active# zip(X1, X2) -> active# X1, active# pairNs() -> incr# oddNs()) (active# zip(X1, X2) -> active# X1, active# s X -> active# X) (active# zip(X1, X2) -> active# X1, active# s X -> s# active X) (active# zip(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2) (active# zip(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2)) (active# zip(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2)) (active# zip(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# zip(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2) (active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(X1, active X2)) (active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(active X1, X2)) (active# zip(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# zip(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# zip(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# zip(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1) (active# zip(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2) (active# zip(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2)) (active# zip(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2)) (active# zip(X1, X2) -> active# X1, active# tail X -> active# X) (active# zip(X1, X2) -> active# X1, active# tail X -> tail# active X) (active# zip(X1, X2) -> active# X1, active# repItems X -> active# X) (active# zip(X1, X2) -> active# X1, active# repItems X -> repItems# active X) (active# zip(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# zip(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# zip(X1, X2) -> active# X1, active# repItems cons(X, XS) -> repItems# XS) (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2)) (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1) (active# cons(X1, X2) -> active# X1, active# incr X -> incr# active X) (active# cons(X1, X2) -> active# X1, active# incr X -> active# X) (active# cons(X1, X2) -> active# X1, active# incr cons(X, XS) -> cons#(s X, incr XS)) (active# cons(X1, X2) -> active# X1, active# incr cons(X, XS) -> incr# XS) (active# cons(X1, X2) -> active# X1, active# incr cons(X, XS) -> s# X) (active# cons(X1, X2) -> active# X1, active# oddNs() -> incr# pairNs()) (active# cons(X1, X2) -> active# X1, active# pairNs() -> cons#(0(), incr oddNs())) (active# cons(X1, X2) -> active# X1, active# pairNs() -> incr# oddNs()) (active# cons(X1, X2) -> active# X1, active# s X -> active# X) (active# cons(X1, X2) -> active# X1, active# s X -> s# active X) (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1) (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2) (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2)) (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2)) (active# cons(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> cons#(X, take(N, XS))) (active# cons(X1, X2) -> active# X1, active# take(s N, cons(X, XS)) -> take#(N, XS)) (active# cons(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X1) (active# cons(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2) (active# cons(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(X1, active X2)) (active# cons(X1, X2) -> active# X1, active# zip(X1, X2) -> zip#(active X1, X2)) (active# cons(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> cons#(pair(X, Y), zip(XS, YS))) (active# cons(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> zip#(XS, YS)) (active# cons(X1, X2) -> active# X1, active# zip(cons(X, XS), cons(Y, YS)) -> pair#(X, Y)) (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1) (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2) (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2)) (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2)) (active# cons(X1, X2) -> active# X1, active# tail X -> active# X) (active# cons(X1, X2) -> active# X1, active# tail X -> tail# active X) (active# cons(X1, X2) -> active# X1, active# repItems X -> active# X) (active# cons(X1, X2) -> active# X1, active# repItems X -> repItems# active X) (active# cons(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, cons(X, repItems XS))) (active# cons(X1, X2) -> active# X1, active# repItems cons(X, XS) -> cons#(X, repItems XS)) (active# cons(X1, X2) -> active# X1, active# repItems cons(X, XS) -> repItems# XS) } STATUS: arrows: 0.871014 SCCS (11): Scc: {top# mark X -> top# proper X, top# ok X -> top# active X} Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X, proper# repItems X -> proper# X} Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2, active# tail X -> active# X, active# repItems X -> active# X} Scc: {repItems# mark X -> repItems# X, repItems# ok X -> repItems# X} Scc: {tail# mark X -> tail# X, tail# ok X -> tail# X} Scc: { pair#(X1, mark X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2)} Scc: { zip#(X1, mark X2) -> zip#(X1, X2), zip#(mark X1, X2) -> zip#(X1, X2), zip#(ok X1, ok X2) -> zip#(X1, X2)} Scc: { take#(X1, mark X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2)} Scc: {s# mark X -> s# X, s# ok X -> s# X} Scc: {incr# mark X -> incr# X, incr# ok X -> incr# X} Scc: { cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2)} SCC (2): Strict: {top# mark X -> top# proper X, top# ok X -> top# active X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} Fail SCC (12): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X, proper# repItems X -> proper# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = x0 + x1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = x0, [repItems](x0) = x0 + 1, [ok](x0) = 0, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 0, [proper#](x0) = x0 Strict: proper# repItems X -> proper# X 1 + 1X >= 0 + 1X proper# tail X -> proper# X 0 + 1X >= 0 + 1X proper# pair(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# pair(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# zip(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# zip(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# take(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# take(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# s X -> proper# X 0 + 1X >= 0 + 1X proper# incr X -> proper# X 0 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 0 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 0 proper oddNs() -> ok oddNs() 0 >= 0 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 0 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 1 + 0X >= 0 + 0X repItems mark X -> mark repItems X 1 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 0 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 0 + 0X >= 0 + 0X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 1 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 0 + 0X >= 0 + 0X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X} SCC (11): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = x0 + x1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = x0 + 1, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 0, [proper#](x0) = x0 Strict: proper# tail X -> proper# X 1 + 1X >= 0 + 1X proper# pair(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# pair(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# zip(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# zip(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# take(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# take(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# s X -> proper# X 0 + 1X >= 0 + 1X proper# incr X -> proper# X 0 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 1 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 1 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2} SCC (10): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = x0 + x1 + 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = x0 + 1, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 0, [proper#](x0) = x0 Strict: proper# pair(X1, X2) -> proper# X2 1 + 1X1 + 1X2 >= 0 + 1X2 proper# pair(X1, X2) -> proper# X1 1 + 1X1 + 1X2 >= 0 + 1X1 proper# zip(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# zip(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# take(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# take(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# s X -> proper# X 0 + 1X >= 0 + 1X proper# incr X -> proper# X 0 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 1 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 1 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2} SCC (8): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2, proper# zip(X1, X2) -> proper# X1, proper# zip(X1, X2) -> proper# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1 + 1, [pair](x0, x1) = x0 + 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 1, [proper#](x0) = x0 Strict: proper# zip(X1, X2) -> proper# X2 1 + 1X1 + 1X2 >= 0 + 1X2 proper# zip(X1, X2) -> proper# X1 1 + 1X1 + 1X2 >= 0 + 1X1 proper# take(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# take(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 proper# s X -> proper# X 0 + 1X >= 0 + 1X proper# incr X -> proper# X 0 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2} SCC (6): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1 + 1, [zip](x0, x1) = x0 + 1, [pair](x0, x1) = 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = x0 + 1, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 1, [proper#](x0) = x0 Strict: proper# take(X1, X2) -> proper# X2 1 + 1X1 + 1X2 >= 0 + 1X2 proper# take(X1, X2) -> proper# X1 1 + 1X1 + 1X2 >= 0 + 1X1 proper# s X -> proper# X 0 + 1X >= 0 + 1X proper# incr X -> proper# X 0 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 1 + 0X >= 0 + 0X proper tail X -> tail proper X 1 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 proper take(X1, X2) -> take(proper X1, proper X2) 2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2 proper nil() -> ok nil() 2 >= 2 proper s X -> s proper X 1 + 1X >= 1 + 1X proper pairNs() -> ok pairNs() 1 >= 1 proper oddNs() -> ok oddNs() 2 >= 2 proper incr X -> incr proper X 1 + 1X >= 1 + 1X proper 0() -> ok 0() 2 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X} SCC (4): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X, proper# s X -> proper# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = 0, [zip](x0, x1) = x0 + 1, [pair](x0, x1) = 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0 + 1, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 1, [proper#](x0) = x0 Strict: proper# s X -> proper# X 1 + 1X >= 0 + 1X proper# incr X -> proper# X 0 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 2 + 1X >= 2 + 1X s mark X -> mark s X 1 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X} SCC (3): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2, proper# incr X -> proper# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = 0, [zip](x0, x1) = 0, [pair](x0, x1) = 0, [mark](x0) = x0, [incr](x0) = x0 + 1, [active](x0) = 0, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 0, [pairNs] = 1, [nil] = 0, [proper#](x0) = x0 Strict: proper# incr X -> proper# X 1 + 1X >= 0 + 1X proper# cons(X1, X2) -> proper# X2 0 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 1 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 1 + 1X >= 1 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 1 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 2X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 1XS active tail X -> tail active X 0 + 0X >= 1 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 2 active oddNs() -> mark incr pairNs() 0 >= 2 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 2 + 0X + 1XS active incr X -> incr active X 0 + 0X >= 1 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 1 + 1X >= 1 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2 SCCS (1): Scc: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2} SCC (2): Strict: {proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = 0, [active](x0) = x0 + 1, [s](x0) = 0, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = x0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [proper#](x0) = x0 Strict: proper# cons(X1, X2) -> proper# X2 1 + 1X1 + 1X2 >= 0 + 1X2 proper# cons(X1, X2) -> proper# X1 1 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 1 + 1X >= 1 + 1X proper tail X -> tail proper X 1 + 1X >= 1 + 1X proper pair(X1, X2) -> pair(proper X1, proper X2) 1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2 proper take(X1, X2) -> take(proper X1, proper X2) 1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 proper nil() -> ok nil() 1 >= 2 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 1 >= 2 proper oddNs() -> ok oddNs() 1 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 1 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 0 + 0X >= 1 + 0X s mark X -> mark s X 0 + 0X >= 1 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 1XS >= 4 + 2X + 1XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 1XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 1XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 3 + 1X + 1XS + 1Y + 1YS >= 3 + 0X + 1XS + 0Y + 1YS active zip(X1, X2) -> zip(active X1, X2) 1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 active zip(X, nil()) -> mark nil() 2 + 1X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 1XS + 0N >= 3 + 1X + 1XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 1 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 1 active incr cons(X, XS) -> mark cons(s X, incr XS) 1 + 0X + 0XS >= 2 + 0X + 0XS active incr X -> incr active X 1 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 incr ok X -> ok incr X 0 + 0X >= 1 + 0X incr mark X -> mark incr X 0 + 0X >= 1 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 Qed SCC (11): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2, active# tail X -> active# X, active# repItems X -> active# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = x0 + x1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = x0, [repItems](x0) = x0 + 1, [ok](x0) = 0, [proper](x0) = 0, [top](x0) = 0, [0] = 0, [oddNs] = 0, [pairNs] = 0, [nil] = 0, [active#](x0) = x0 Strict: active# repItems X -> active# X 1 + 1X >= 0 + 1X active# tail X -> active# X 0 + 1X >= 0 + 1X active# pair(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# pair(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# zip(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# zip(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# take(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# take(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# s X -> active# X 0 + 1X >= 0 + 1X active# incr X -> active# X 0 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 0X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 0 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 0 proper oddNs() -> ok oddNs() 0 >= 0 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 0 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 1 + 0X >= 0 + 0X repItems mark X -> mark repItems X 1 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 0 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 0 + 0X >= 0 + 0X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 1 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 incr ok X -> ok incr X 0 + 0X >= 0 + 0X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2, active# tail X -> active# X} SCC (10): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2, active# tail X -> active# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = x0 + x1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = x0 + 1, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 0, [active#](x0) = x0 Strict: active# tail X -> active# X 1 + 1X >= 0 + 1X active# pair(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# pair(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# zip(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# zip(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# take(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# take(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# s X -> active# X 0 + 1X >= 0 + 1X active# incr X -> active# X 0 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 1 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 1 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2} SCC (9): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1, [pair](x0, x1) = x0 + x1 + 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = x0 + 1, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 0, [active#](x0) = x0 Strict: active# pair(X1, X2) -> active# X2 1 + 1X1 + 1X2 >= 0 + 1X2 active# pair(X1, X2) -> active# X1 1 + 1X1 + 1X2 >= 0 + 1X1 active# zip(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# zip(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# take(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# take(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# s X -> active# X 0 + 1X >= 0 + 1X active# incr X -> active# X 0 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 1 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 1 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2} SCC (7): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2, active# zip(X1, X2) -> active# X1, active# zip(X1, X2) -> active# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1, [zip](x0, x1) = x0 + x1 + 1, [pair](x0, x1) = 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 1, [active#](x0) = x0 Strict: active# zip(X1, X2) -> active# X2 1 + 1X1 + 1X2 >= 0 + 1X2 active# zip(X1, X2) -> active# X1 1 + 1X1 + 1X2 >= 0 + 1X1 active# take(X1, X2) -> active# X2 0 + 1X1 + 1X2 >= 0 + 1X2 active# take(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 active# s X -> active# X 0 + 1X >= 0 + 1X active# incr X -> active# X 0 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2} SCC (5): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X, active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = x0 + x1 + 1, [zip](x0, x1) = x0 + 1, [pair](x0, x1) = 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 1, [active#](x0) = x0 Strict: active# take(X1, X2) -> active# X2 1 + 1X1 + 1X2 >= 0 + 1X2 active# take(X1, X2) -> active# X1 1 + 1X1 + 1X2 >= 0 + 1X1 active# s X -> active# X 0 + 1X >= 0 + 1X active# incr X -> active# X 0 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 1X >= 1 + 1X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X} SCC (3): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X, active# s X -> active# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = 0, [zip](x0, x1) = x0 + 1, [pair](x0, x1) = 1, [mark](x0) = 0, [incr](x0) = x0, [active](x0) = 0, [s](x0) = x0 + 1, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 0, [nil] = 1, [active#](x0) = x0 Strict: active# s X -> active# X 1 + 1X >= 0 + 1X active# incr X -> active# X 0 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 1 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 2 + 1X >= 2 + 1X s mark X -> mark s X 1 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 1 + 1X >= 1 + 1X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X} SCC (2): Strict: {active# cons(X1, X2) -> active# X1, active# incr X -> active# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + x1, [take](x0, x1) = 0, [zip](x0, x1) = x0 + 1, [pair](x0, x1) = 1, [mark](x0) = 0, [incr](x0) = x0 + 1, [active](x0) = 0, [s](x0) = 1, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 0, [pairNs] = 1, [nil] = 1, [active#](x0) = x0 Strict: active# incr X -> active# X 1 + 1X >= 0 + 1X active# cons(X1, X2) -> active# X1 0 + 1X1 + 1X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 1 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 0XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 1 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 1 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {active# cons(X1, X2) -> active# X1} SCC (1): Strict: {active# cons(X1, X2) -> active# X1} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = x0 + 1, [pair](x0, x1) = 1, [mark](x0) = 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 0, [active#](x0) = x0 Strict: active# cons(X1, X2) -> active# X1 1 + 1X1 + 0X2 >= 0 + 1X1 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 0X >= 1 + 0X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 0X >= 1 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 1 + 0X active repItems nil() -> mark nil() 2 >= 1 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 1 + 0X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 0XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 1XS >= 1 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 3 + 0X + 0XS + 1Y + 0YS >= 1 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 1 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 1 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 1 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 1 active oddNs() -> mark incr pairNs() 2 >= 1 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 1 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 0X >= 1 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 Qed SCC (2): Strict: {repItems# mark X -> repItems# X, repItems# ok X -> repItems# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = 0, [take](x0, x1) = 0, [zip](x0, x1) = 0, [pair](x0, x1) = 0, [mark](x0) = x0, [incr](x0) = 0, [active](x0) = 0, [s](x0) = 0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 0, [repItems#](x0) = x0 Strict: repItems# ok X -> repItems# X 1 + 1X >= 0 + 1X repItems# mark X -> repItems# X 0 + 1X >= 0 + 1X Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 0 + 0X >= 1 + 0X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 1XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 incr ok X -> ok incr X 0 + 0X >= 1 + 0X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {repItems# mark X -> repItems# X} SCC (1): Strict: {repItems# mark X -> repItems# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [repItems#](x0) = x0 Strict: repItems# mark X -> repItems# X 1 + 1X >= 0 + 1X Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (2): Strict: {tail# mark X -> tail# X, tail# ok X -> tail# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = 0, [take](x0, x1) = 0, [zip](x0, x1) = 0, [pair](x0, x1) = 0, [mark](x0) = x0, [incr](x0) = 0, [active](x0) = 0, [s](x0) = 0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 0, [tail#](x0) = x0 Strict: tail# ok X -> tail# X 1 + 1X >= 0 + 1X tail# mark X -> tail# X 0 + 1X >= 0 + 1X Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 0 + 0X >= 1 + 0X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 1XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 incr ok X -> ok incr X 0 + 0X >= 1 + 0X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {tail# mark X -> tail# X} SCC (1): Strict: {tail# mark X -> tail# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [tail#](x0) = x0 Strict: tail# mark X -> tail# X 1 + 1X >= 0 + 1X Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (3): Strict: { pair#(X1, mark X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = x0 + 1, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [pair#](x0, x1) = x0 + 1 Strict: pair#(ok X1, ok X2) -> pair#(X1, X2) 2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 pair#(mark X1, X2) -> pair#(X1, X2) 2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 pair#(X1, mark X2) -> pair#(X1, X2) 1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 2 + 1X >= 2 + 1X proper tail X -> tail proper X 2 + 1X >= 2 + 1X proper pair(X1, X2) -> pair(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 proper nil() -> ok nil() 2 >= 2 proper s X -> s proper X 2 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 2 >= 2 proper oddNs() -> ok oddNs() 2 >= 2 proper incr X -> incr proper X 2 + 1X >= 2 + 1X proper 0() -> ok 0() 2 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 SCCS (1): Scc: {pair#(X1, mark X2) -> pair#(X1, X2)} SCC (1): Strict: {pair#(X1, mark X2) -> pair#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [pair#](x0, x1) = x0 Strict: pair#(X1, mark X2) -> pair#(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2 Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (3): Strict: { zip#(X1, mark X2) -> zip#(X1, X2), zip#(mark X1, X2) -> zip#(X1, X2), zip#(ok X1, ok X2) -> zip#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = x0 + 1, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [zip#](x0, x1) = x0 + 1 Strict: zip#(ok X1, ok X2) -> zip#(X1, X2) 2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 zip#(mark X1, X2) -> zip#(X1, X2) 2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 zip#(X1, mark X2) -> zip#(X1, X2) 1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 2 + 1X >= 2 + 1X proper tail X -> tail proper X 2 + 1X >= 2 + 1X proper pair(X1, X2) -> pair(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 proper nil() -> ok nil() 2 >= 2 proper s X -> s proper X 2 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 2 >= 2 proper oddNs() -> ok oddNs() 2 >= 2 proper incr X -> incr proper X 2 + 1X >= 2 + 1X proper 0() -> ok 0() 2 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 SCCS (1): Scc: {zip#(X1, mark X2) -> zip#(X1, X2)} SCC (1): Strict: {zip#(X1, mark X2) -> zip#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [zip#](x0, x1) = x0 Strict: zip#(X1, mark X2) -> zip#(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2 Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (3): Strict: { take#(X1, mark X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = x0 + 1, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [take#](x0, x1) = x0 + 1 Strict: take#(ok X1, ok X2) -> take#(X1, X2) 2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 take#(mark X1, X2) -> take#(X1, X2) 2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 take#(X1, mark X2) -> take#(X1, X2) 1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 2 + 1X >= 2 + 1X proper tail X -> tail proper X 2 + 1X >= 2 + 1X proper pair(X1, X2) -> pair(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 proper nil() -> ok nil() 2 >= 2 proper s X -> s proper X 2 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 2 >= 2 proper oddNs() -> ok oddNs() 2 >= 2 proper incr X -> incr proper X 2 + 1X >= 2 + 1X proper 0() -> ok 0() 2 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 SCCS (1): Scc: {take#(X1, mark X2) -> take#(X1, X2)} SCC (1): Strict: {take#(X1, mark X2) -> take#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [take#](x0, x1) = x0 Strict: take#(X1, mark X2) -> take#(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2 Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (2): Strict: {s# mark X -> s# X, s# ok X -> s# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = 0, [take](x0, x1) = 0, [zip](x0, x1) = 0, [pair](x0, x1) = 0, [mark](x0) = x0, [incr](x0) = 0, [active](x0) = 0, [s](x0) = 0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 0, [s#](x0) = x0 Strict: s# ok X -> s# X 1 + 1X >= 0 + 1X s# mark X -> s# X 0 + 1X >= 0 + 1X Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 0 + 0X >= 1 + 0X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 1XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 incr ok X -> ok incr X 0 + 0X >= 1 + 0X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {s# mark X -> s# X} SCC (1): Strict: {s# mark X -> s# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [s#](x0) = x0 Strict: s# mark X -> s# X 1 + 1X >= 0 + 1X Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (2): Strict: {incr# mark X -> incr# X, incr# ok X -> incr# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = 0, [take](x0, x1) = 0, [zip](x0, x1) = 0, [pair](x0, x1) = 0, [mark](x0) = x0, [incr](x0) = 0, [active](x0) = 0, [s](x0) = 0, [tail](x0) = 0, [repItems](x0) = 0, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 0, [incr#](x0) = x0 Strict: incr# ok X -> incr# X 1 + 1X >= 0 + 1X incr# mark X -> incr# X 0 + 1X >= 0 + 1X Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 0 + 0X >= 0 + 0X proper tail X -> tail proper X 0 + 0X >= 0 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 1 proper s X -> s proper X 0 + 0X >= 0 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 0 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 repItems ok X -> ok repItems X 0 + 0X >= 1 + 0X repItems mark X -> mark repItems X 0 + 0X >= 0 + 0X tail ok X -> ok tail X 0 + 0X >= 1 + 0X tail mark X -> mark tail X 0 + 0X >= 0 + 0X pair(ok X1, ok X2) -> ok pair(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 take(mark X1, X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 take(X1, mark X2) -> mark take(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 s ok X -> ok s X 0 + 0X >= 1 + 0X s mark X -> mark s X 0 + 0X >= 0 + 0X active repItems nil() -> mark nil() 0 >= 0 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 0 + 0X + 0XS >= 0 + 0X + 0XS active repItems X -> repItems active X 0 + 0X >= 0 + 0X active tail cons(X, XS) -> mark XS 0 + 0X + 0XS >= 0 + 1XS active tail X -> tail active X 0 + 0X >= 0 + 0X active pair(X1, X2) -> pair(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 0 + 0XS >= 0 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 0 + 0X >= 0 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 0 + 0X + 0XS + 0N >= 0 + 0X + 0XS + 0N active take(0(), XS) -> mark nil() 0 + 0XS >= 0 active take(X1, X2) -> take(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active take(X1, X2) -> take(X1, active X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 active s X -> s active X 0 + 0X >= 0 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 0 >= 0 active oddNs() -> mark incr pairNs() 0 >= 0 active incr cons(X, XS) -> mark cons(s X, incr XS) 0 + 0X + 0XS >= 0 + 0X + 0XS active incr X -> incr active X 0 + 0X >= 0 + 0X active cons(X1, X2) -> cons(active X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 incr ok X -> ok incr X 0 + 0X >= 1 + 0X incr mark X -> mark incr X 0 + 0X >= 0 + 0X cons(ok X1, ok X2) -> ok cons(X1, X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2 SCCS (1): Scc: {incr# mark X -> incr# X} SCC (1): Strict: {incr# mark X -> incr# X} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [incr#](x0) = x0 Strict: incr# mark X -> incr# X 1 + 1X >= 0 + 1X Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed SCC (2): Strict: { cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = x0, [top](x0) = 0, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [cons#](x0, x1) = x0 Strict: cons#(ok X1, ok X2) -> cons#(X1, X2) 1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2 cons#(mark X1, X2) -> cons#(X1, X2) 0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2 Weak: top ok X -> top active X 0 + 0X >= 0 + 0X top mark X -> top proper X 0 + 0X >= 0 + 0X proper repItems X -> repItems proper X 1 + 1X >= 1 + 1X proper tail X -> tail proper X 1 + 1X >= 1 + 1X proper pair(X1, X2) -> pair(proper X1, proper X2) 1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 proper nil() -> ok nil() 1 >= 2 proper s X -> s proper X 1 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 1 >= 2 proper oddNs() -> ok oddNs() 1 >= 2 proper incr X -> incr proper X 1 + 1X >= 1 + 1X proper 0() -> ok 0() 1 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 SCCS (1): Scc: {cons#(mark X1, X2) -> cons#(X1, X2)} SCC (1): Strict: {cons#(mark X1, X2) -> cons#(X1, X2)} Weak: { cons(mark X1, X2) -> mark cons(X1, X2), cons(ok X1, ok X2) -> ok cons(X1, X2), incr mark X -> mark incr X, incr ok X -> ok incr X, active cons(X1, X2) -> cons(active X1, X2), active incr X -> incr active X, active incr cons(X, XS) -> mark cons(s X, incr XS), active oddNs() -> mark incr pairNs(), active pairNs() -> mark cons(0(), incr oddNs()), active s X -> s active X, active take(X1, X2) -> take(X1, active X2), active take(X1, X2) -> take(active X1, X2), active take(0(), XS) -> mark nil(), active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)), active zip(X, nil()) -> mark nil(), active zip(X1, X2) -> zip(X1, active X2), active zip(X1, X2) -> zip(active X1, X2), active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)), active zip(nil(), XS) -> mark nil(), active pair(X1, X2) -> pair(X1, active X2), active pair(X1, X2) -> pair(active X1, X2), active tail X -> tail active X, active tail cons(X, XS) -> mark XS, active repItems X -> repItems active X, active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)), active repItems nil() -> mark nil(), s mark X -> mark s X, s ok X -> ok s X, take(X1, mark X2) -> mark take(X1, X2), take(mark X1, X2) -> mark take(X1, X2), take(ok X1, ok X2) -> ok take(X1, X2), zip(X1, mark X2) -> mark zip(X1, X2), zip(mark X1, X2) -> mark zip(X1, X2), zip(ok X1, ok X2) -> ok zip(X1, X2), pair(X1, mark X2) -> mark pair(X1, X2), pair(mark X1, X2) -> mark pair(X1, X2), pair(ok X1, ok X2) -> ok pair(X1, X2), tail mark X -> mark tail X, tail ok X -> ok tail X, repItems mark X -> mark repItems X, repItems ok X -> ok repItems X, proper cons(X1, X2) -> cons(proper X1, proper X2), proper 0() -> ok 0(), proper incr X -> incr proper X, proper oddNs() -> ok oddNs(), proper pairNs() -> ok pairNs(), proper s X -> s proper X, proper nil() -> ok nil(), proper take(X1, X2) -> take(proper X1, proper X2), proper zip(X1, X2) -> zip(proper X1, proper X2), proper pair(X1, X2) -> pair(proper X1, proper X2), proper tail X -> tail proper X, proper repItems X -> repItems proper X, top mark X -> top proper X, top ok X -> top active X} POLY: Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true Interpretation: [cons](x0, x1) = x0 + 1, [take](x0, x1) = x0 + 1, [zip](x0, x1) = 1, [pair](x0, x1) = 1, [mark](x0) = x0 + 1, [incr](x0) = x0 + 1, [active](x0) = x0 + 1, [s](x0) = 1, [tail](x0) = x0 + 1, [repItems](x0) = x0 + 1, [ok](x0) = x0 + 1, [proper](x0) = 0, [top](x0) = x0 + 1, [0] = 1, [oddNs] = 1, [pairNs] = 1, [nil] = 1, [cons#](x0, x1) = x0 Strict: cons#(mark X1, X2) -> cons#(X1, X2) 1 + 1X1 + 0X2 >= 0 + 1X1 + 0X2 Weak: top ok X -> top active X 2 + 1X >= 2 + 1X top mark X -> top proper X 2 + 1X >= 1 + 0X proper repItems X -> repItems proper X 0 + 0X >= 1 + 0X proper tail X -> tail proper X 0 + 0X >= 1 + 0X proper pair(X1, X2) -> pair(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper zip(X1, X2) -> zip(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper take(X1, X2) -> take(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 proper nil() -> ok nil() 0 >= 2 proper s X -> s proper X 0 + 0X >= 1 + 0X proper pairNs() -> ok pairNs() 0 >= 2 proper oddNs() -> ok oddNs() 0 >= 2 proper incr X -> incr proper X 0 + 0X >= 1 + 0X proper 0() -> ok 0() 0 >= 2 proper cons(X1, X2) -> cons(proper X1, proper X2) 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 repItems ok X -> ok repItems X 2 + 1X >= 2 + 1X repItems mark X -> mark repItems X 2 + 1X >= 2 + 1X tail ok X -> ok tail X 2 + 1X >= 2 + 1X tail mark X -> mark tail X 2 + 1X >= 2 + 1X pair(ok X1, ok X2) -> ok pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(mark X1, X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 pair(X1, mark X2) -> mark pair(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(ok X1, ok X2) -> ok zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(mark X1, X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 zip(X1, mark X2) -> mark zip(X1, X2) 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2 take(ok X1, ok X2) -> ok take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(mark X1, X2) -> mark take(X1, X2) 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 take(X1, mark X2) -> mark take(X1, X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 s ok X -> ok s X 1 + 0X >= 2 + 0X s mark X -> mark s X 1 + 0X >= 2 + 0X active repItems nil() -> mark nil() 3 >= 2 active repItems cons(X, XS) -> mark cons(X, cons(X, repItems XS)) 3 + 1X + 0XS >= 2 + 1X + 0XS active repItems X -> repItems active X 2 + 1X >= 2 + 1X active tail cons(X, XS) -> mark XS 3 + 1X + 0XS >= 1 + 1XS active tail X -> tail active X 2 + 1X >= 2 + 1X active pair(X1, X2) -> pair(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active pair(X1, X2) -> pair(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(nil(), XS) -> mark nil() 2 + 0XS >= 2 active zip(cons(X, XS), cons(Y, YS)) -> mark cons(pair(X, Y), zip(XS, YS)) 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS active zip(X1, X2) -> zip(active X1, X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X1, X2) -> zip(X1, active X2) 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2 active zip(X, nil()) -> mark nil() 2 + 0X >= 2 active take(s N, cons(X, XS)) -> mark cons(X, take(N, XS)) 3 + 1X + 0XS + 0N >= 2 + 1X + 0XS + 0N active take(0(), XS) -> mark nil() 2 + 1XS >= 2 active take(X1, X2) -> take(active X1, X2) 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2 active take(X1, X2) -> take(X1, active X2) 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2 active s X -> s active X 2 + 0X >= 1 + 0X active pairNs() -> mark cons(0(), incr oddNs()) 2 >= 3 active oddNs() -> mark incr pairNs() 2 >= 3 active incr cons(X, XS) -> mark cons(s X, incr XS) 3 + 1X + 0XS >= 3 + 0X + 0XS active incr X -> incr active X 2 + 1X >= 2 + 1X active cons(X1, X2) -> cons(active X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 incr ok X -> ok incr X 2 + 1X >= 2 + 1X incr mark X -> mark incr X 2 + 1X >= 2 + 1X cons(ok X1, ok X2) -> ok cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 cons(mark X1, X2) -> mark cons(X1, X2) 2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2 Qed