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