MAYBE

Problem:
 active(pairNs()) -> mark(cons(0(),incr(oddNs())))
 active(oddNs()) -> mark(incr(pairNs()))
 active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
 active(take(0(),XS)) -> mark(nil())
 active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
 active(zip(nil(),XS)) -> mark(nil())
 active(zip(X,nil())) -> mark(nil())
 active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
 active(tail(cons(X,XS))) -> mark(XS)
 active(repItems(nil())) -> mark(nil())
 active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
 active(cons(X1,X2)) -> cons(active(X1),X2)
 active(incr(X)) -> incr(active(X))
 active(s(X)) -> s(active(X))
 active(take(X1,X2)) -> take(active(X1),X2)
 active(take(X1,X2)) -> take(X1,active(X2))
 active(zip(X1,X2)) -> zip(active(X1),X2)
 active(zip(X1,X2)) -> zip(X1,active(X2))
 active(pair(X1,X2)) -> pair(active(X1),X2)
 active(pair(X1,X2)) -> pair(X1,active(X2))
 active(tail(X)) -> tail(active(X))
 active(repItems(X)) -> repItems(active(X))
 cons(mark(X1),X2) -> mark(cons(X1,X2))
 incr(mark(X)) -> mark(incr(X))
 s(mark(X)) -> mark(s(X))
 take(mark(X1),X2) -> mark(take(X1,X2))
 take(X1,mark(X2)) -> mark(take(X1,X2))
 zip(mark(X1),X2) -> mark(zip(X1,X2))
 zip(X1,mark(X2)) -> mark(zip(X1,X2))
 pair(mark(X1),X2) -> mark(pair(X1,X2))
 pair(X1,mark(X2)) -> mark(pair(X1,X2))
 tail(mark(X)) -> mark(tail(X))
 repItems(mark(X)) -> mark(repItems(X))
 proper(pairNs()) -> ok(pairNs())
 proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
 proper(0()) -> ok(0())
 proper(incr(X)) -> incr(proper(X))
 proper(oddNs()) -> ok(oddNs())
 proper(s(X)) -> s(proper(X))
 proper(take(X1,X2)) -> take(proper(X1),proper(X2))
 proper(nil()) -> ok(nil())
 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))
 cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
 incr(ok(X)) -> ok(incr(X))
 s(ok(X)) -> ok(s(X))
 take(ok(X1),ok(X2)) -> ok(take(X1,X2))
 zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
 pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
 tail(ok(X)) -> ok(tail(X))
 repItems(ok(X)) -> ok(repItems(X))
 top(mark(X)) -> top(proper(X))
 top(ok(X)) -> top(active(X))

Proof:
 DP Processor:
  DPs:
   active#(pairNs()) -> incr#(oddNs())
   active#(pairNs()) -> cons#(0(),incr(oddNs()))
   active#(oddNs()) -> incr#(pairNs())
   active#(incr(cons(X,XS))) -> incr#(XS)
   active#(incr(cons(X,XS))) -> s#(X)
   active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
   active#(take(s(N),cons(X,XS))) -> take#(N,XS)
   active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
   active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
   active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
   active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
   active#(repItems(cons(X,XS))) -> repItems#(XS)
   active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
   active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
   active#(cons(X1,X2)) -> active#(X1)
   active#(cons(X1,X2)) -> cons#(active(X1),X2)
   active#(incr(X)) -> active#(X)
   active#(incr(X)) -> incr#(active(X))
   active#(s(X)) -> active#(X)
   active#(s(X)) -> s#(active(X))
   active#(take(X1,X2)) -> active#(X1)
   active#(take(X1,X2)) -> take#(active(X1),X2)
   active#(take(X1,X2)) -> active#(X2)
   active#(take(X1,X2)) -> take#(X1,active(X2))
   active#(zip(X1,X2)) -> active#(X1)
   active#(zip(X1,X2)) -> zip#(active(X1),X2)
   active#(zip(X1,X2)) -> active#(X2)
   active#(zip(X1,X2)) -> zip#(X1,active(X2))
   active#(pair(X1,X2)) -> active#(X1)
   active#(pair(X1,X2)) -> pair#(active(X1),X2)
   active#(pair(X1,X2)) -> active#(X2)
   active#(pair(X1,X2)) -> pair#(X1,active(X2))
   active#(tail(X)) -> active#(X)
   active#(tail(X)) -> tail#(active(X))
   active#(repItems(X)) -> active#(X)
   active#(repItems(X)) -> repItems#(active(X))
   cons#(mark(X1),X2) -> cons#(X1,X2)
   incr#(mark(X)) -> incr#(X)
   s#(mark(X)) -> s#(X)
   take#(mark(X1),X2) -> take#(X1,X2)
   take#(X1,mark(X2)) -> take#(X1,X2)
   zip#(mark(X1),X2) -> zip#(X1,X2)
   zip#(X1,mark(X2)) -> zip#(X1,X2)
   pair#(mark(X1),X2) -> pair#(X1,X2)
   pair#(X1,mark(X2)) -> pair#(X1,X2)
   tail#(mark(X)) -> tail#(X)
   repItems#(mark(X)) -> repItems#(X)
   proper#(cons(X1,X2)) -> proper#(X2)
   proper#(cons(X1,X2)) -> proper#(X1)
   proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
   proper#(incr(X)) -> proper#(X)
   proper#(incr(X)) -> incr#(proper(X))
   proper#(s(X)) -> proper#(X)
   proper#(s(X)) -> s#(proper(X))
   proper#(take(X1,X2)) -> proper#(X2)
   proper#(take(X1,X2)) -> proper#(X1)
   proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
   proper#(zip(X1,X2)) -> proper#(X2)
   proper#(zip(X1,X2)) -> proper#(X1)
   proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
   proper#(pair(X1,X2)) -> proper#(X2)
   proper#(pair(X1,X2)) -> proper#(X1)
   proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
   proper#(tail(X)) -> proper#(X)
   proper#(tail(X)) -> tail#(proper(X))
   proper#(repItems(X)) -> proper#(X)
   proper#(repItems(X)) -> repItems#(proper(X))
   cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
   incr#(ok(X)) -> incr#(X)
   s#(ok(X)) -> s#(X)
   take#(ok(X1),ok(X2)) -> take#(X1,X2)
   zip#(ok(X1),ok(X2)) -> zip#(X1,X2)
   pair#(ok(X1),ok(X2)) -> pair#(X1,X2)
   tail#(ok(X)) -> tail#(X)
   repItems#(ok(X)) -> repItems#(X)
   top#(mark(X)) -> proper#(X)
   top#(mark(X)) -> top#(proper(X))
   top#(ok(X)) -> active#(X)
   top#(ok(X)) -> top#(active(X))
  TRS:
   active(pairNs()) -> mark(cons(0(),incr(oddNs())))
   active(oddNs()) -> mark(incr(pairNs()))
   active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
   active(take(0(),XS)) -> mark(nil())
   active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
   active(zip(nil(),XS)) -> mark(nil())
   active(zip(X,nil())) -> mark(nil())
   active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
   active(tail(cons(X,XS))) -> mark(XS)
   active(repItems(nil())) -> mark(nil())
   active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
   active(cons(X1,X2)) -> cons(active(X1),X2)
   active(incr(X)) -> incr(active(X))
   active(s(X)) -> s(active(X))
   active(take(X1,X2)) -> take(active(X1),X2)
   active(take(X1,X2)) -> take(X1,active(X2))
   active(zip(X1,X2)) -> zip(active(X1),X2)
   active(zip(X1,X2)) -> zip(X1,active(X2))
   active(pair(X1,X2)) -> pair(active(X1),X2)
   active(pair(X1,X2)) -> pair(X1,active(X2))
   active(tail(X)) -> tail(active(X))
   active(repItems(X)) -> repItems(active(X))
   cons(mark(X1),X2) -> mark(cons(X1,X2))
   incr(mark(X)) -> mark(incr(X))
   s(mark(X)) -> mark(s(X))
   take(mark(X1),X2) -> mark(take(X1,X2))
   take(X1,mark(X2)) -> mark(take(X1,X2))
   zip(mark(X1),X2) -> mark(zip(X1,X2))
   zip(X1,mark(X2)) -> mark(zip(X1,X2))
   pair(mark(X1),X2) -> mark(pair(X1,X2))
   pair(X1,mark(X2)) -> mark(pair(X1,X2))
   tail(mark(X)) -> mark(tail(X))
   repItems(mark(X)) -> mark(repItems(X))
   proper(pairNs()) -> ok(pairNs())
   proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
   proper(0()) -> ok(0())
   proper(incr(X)) -> incr(proper(X))
   proper(oddNs()) -> ok(oddNs())
   proper(s(X)) -> s(proper(X))
   proper(take(X1,X2)) -> take(proper(X1),proper(X2))
   proper(nil()) -> ok(nil())
   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))
   cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
   incr(ok(X)) -> ok(incr(X))
   s(ok(X)) -> ok(s(X))
   take(ok(X1),ok(X2)) -> ok(take(X1,X2))
   zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
   pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
   tail(ok(X)) -> ok(tail(X))
   repItems(ok(X)) -> ok(repItems(X))
   top(mark(X)) -> top(proper(X))
   top(ok(X)) -> top(active(X))
  EDG Processor:
   DPs:
    active#(pairNs()) -> incr#(oddNs())
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(oddNs()) -> incr#(pairNs())
    active#(incr(cons(X,XS))) -> incr#(XS)
    active#(incr(cons(X,XS))) -> s#(X)
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
    active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
    active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
    active#(repItems(cons(X,XS))) -> repItems#(XS)
    active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
    active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
    active#(cons(X1,X2)) -> active#(X1)
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    active#(incr(X)) -> active#(X)
    active#(incr(X)) -> incr#(active(X))
    active#(s(X)) -> active#(X)
    active#(s(X)) -> s#(active(X))
    active#(take(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(take(X1,X2)) -> active#(X2)
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(zip(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(zip(X1,X2)) -> active#(X2)
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(pair(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(pair(X1,X2)) -> active#(X2)
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(tail(X)) -> active#(X)
    active#(tail(X)) -> tail#(active(X))
    active#(repItems(X)) -> active#(X)
    active#(repItems(X)) -> repItems#(active(X))
    cons#(mark(X1),X2) -> cons#(X1,X2)
    incr#(mark(X)) -> incr#(X)
    s#(mark(X)) -> s#(X)
    take#(mark(X1),X2) -> take#(X1,X2)
    take#(X1,mark(X2)) -> take#(X1,X2)
    zip#(mark(X1),X2) -> zip#(X1,X2)
    zip#(X1,mark(X2)) -> zip#(X1,X2)
    pair#(mark(X1),X2) -> pair#(X1,X2)
    pair#(X1,mark(X2)) -> pair#(X1,X2)
    tail#(mark(X)) -> tail#(X)
    repItems#(mark(X)) -> repItems#(X)
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(incr(X)) -> proper#(X)
    proper#(incr(X)) -> incr#(proper(X))
    proper#(s(X)) -> proper#(X)
    proper#(s(X)) -> s#(proper(X))
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(tail(X)) -> proper#(X)
    proper#(tail(X)) -> tail#(proper(X))
    proper#(repItems(X)) -> proper#(X)
    proper#(repItems(X)) -> repItems#(proper(X))
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
    incr#(ok(X)) -> incr#(X)
    s#(ok(X)) -> s#(X)
    take#(ok(X1),ok(X2)) -> take#(X1,X2)
    zip#(ok(X1),ok(X2)) -> zip#(X1,X2)
    pair#(ok(X1),ok(X2)) -> pair#(X1,X2)
    tail#(ok(X)) -> tail#(X)
    repItems#(ok(X)) -> repItems#(X)
    top#(mark(X)) -> proper#(X)
    top#(mark(X)) -> top#(proper(X))
    top#(ok(X)) -> active#(X)
    top#(ok(X)) -> top#(active(X))
   TRS:
    active(pairNs()) -> mark(cons(0(),incr(oddNs())))
    active(oddNs()) -> mark(incr(pairNs()))
    active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
    active(take(0(),XS)) -> mark(nil())
    active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
    active(zip(nil(),XS)) -> mark(nil())
    active(zip(X,nil())) -> mark(nil())
    active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
    active(tail(cons(X,XS))) -> mark(XS)
    active(repItems(nil())) -> mark(nil())
    active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
    active(cons(X1,X2)) -> cons(active(X1),X2)
    active(incr(X)) -> incr(active(X))
    active(s(X)) -> s(active(X))
    active(take(X1,X2)) -> take(active(X1),X2)
    active(take(X1,X2)) -> take(X1,active(X2))
    active(zip(X1,X2)) -> zip(active(X1),X2)
    active(zip(X1,X2)) -> zip(X1,active(X2))
    active(pair(X1,X2)) -> pair(active(X1),X2)
    active(pair(X1,X2)) -> pair(X1,active(X2))
    active(tail(X)) -> tail(active(X))
    active(repItems(X)) -> repItems(active(X))
    cons(mark(X1),X2) -> mark(cons(X1,X2))
    incr(mark(X)) -> mark(incr(X))
    s(mark(X)) -> mark(s(X))
    take(mark(X1),X2) -> mark(take(X1,X2))
    take(X1,mark(X2)) -> mark(take(X1,X2))
    zip(mark(X1),X2) -> mark(zip(X1,X2))
    zip(X1,mark(X2)) -> mark(zip(X1,X2))
    pair(mark(X1),X2) -> mark(pair(X1,X2))
    pair(X1,mark(X2)) -> mark(pair(X1,X2))
    tail(mark(X)) -> mark(tail(X))
    repItems(mark(X)) -> mark(repItems(X))
    proper(pairNs()) -> ok(pairNs())
    proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
    proper(0()) -> ok(0())
    proper(incr(X)) -> incr(proper(X))
    proper(oddNs()) -> ok(oddNs())
    proper(s(X)) -> s(proper(X))
    proper(take(X1,X2)) -> take(proper(X1),proper(X2))
    proper(nil()) -> ok(nil())
    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))
    cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
    incr(ok(X)) -> ok(incr(X))
    s(ok(X)) -> ok(s(X))
    take(ok(X1),ok(X2)) -> ok(take(X1,X2))
    zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
    pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
    tail(ok(X)) -> ok(tail(X))
    repItems(ok(X)) -> ok(repItems(X))
    top(mark(X)) -> top(proper(X))
    top(ok(X)) -> top(active(X))
   graph:
    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))
    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))) -> incr#(XS)
    top#(ok(X)) -> active#(X) -> active#(incr(cons(X,XS))) -> s#(X)
    top#(ok(X)) -> active#(X) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    top#(ok(X)) -> active#(X) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    top#(ok(X)) -> active#(X) -> active#(s(X)) -> s#(active(X))
    top#(ok(X)) -> active#(X) -> active#(take(X1,X2)) -> active#(X1)
    top#(ok(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    top#(ok(X)) -> active#(X) -> active#(take(X1,X2)) -> active#(X2)
    top#(ok(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    top#(ok(X)) -> active#(X) -> active#(zip(X1,X2)) -> active#(X1)
    top#(ok(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    top#(ok(X)) -> active#(X) -> active#(zip(X1,X2)) -> active#(X2)
    top#(ok(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    top#(ok(X)) -> active#(X) -> active#(pair(X1,X2)) -> active#(X1)
    top#(ok(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    top#(ok(X)) -> active#(X) -> active#(pair(X1,X2)) -> active#(X2)
    top#(ok(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    top#(ok(X)) -> active#(X) -> active#(tail(X)) -> active#(X)
    top#(ok(X)) -> active#(X) -> active#(tail(X)) -> tail#(active(X))
    top#(ok(X)) -> active#(X) -> active#(repItems(X)) -> active#(X)
    top#(ok(X)) -> active#(X) ->
    active#(repItems(X)) -> repItems#(active(X))
    top#(mark(X)) -> top#(proper(X)) -> top#(mark(X)) -> proper#(X)
    top#(mark(X)) -> top#(proper(X)) ->
    top#(mark(X)) -> top#(proper(X))
    top#(mark(X)) -> top#(proper(X)) -> top#(ok(X)) -> active#(X)
    top#(mark(X)) -> top#(proper(X)) -> top#(ok(X)) -> top#(active(X))
    top#(mark(X)) -> proper#(X) -> proper#(cons(X1,X2)) -> proper#(X2)
    top#(mark(X)) -> proper#(X) -> proper#(cons(X1,X2)) -> proper#(X1)
    top#(mark(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    top#(mark(X)) -> proper#(X) -> proper#(incr(X)) -> proper#(X)
    top#(mark(X)) -> proper#(X) -> proper#(incr(X)) -> incr#(proper(X))
    top#(mark(X)) -> proper#(X) -> proper#(s(X)) -> proper#(X)
    top#(mark(X)) -> proper#(X) -> proper#(s(X)) -> s#(proper(X))
    top#(mark(X)) -> proper#(X) -> proper#(take(X1,X2)) -> proper#(X2)
    top#(mark(X)) -> proper#(X) -> proper#(take(X1,X2)) -> proper#(X1)
    top#(mark(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    top#(mark(X)) -> proper#(X) -> proper#(zip(X1,X2)) -> proper#(X2)
    top#(mark(X)) -> proper#(X) -> proper#(zip(X1,X2)) -> proper#(X1)
    top#(mark(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    top#(mark(X)) -> proper#(X) -> proper#(pair(X1,X2)) -> proper#(X2)
    top#(mark(X)) -> proper#(X) -> proper#(pair(X1,X2)) -> proper#(X1)
    top#(mark(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    top#(mark(X)) -> proper#(X) -> proper#(tail(X)) -> proper#(X)
    top#(mark(X)) -> proper#(X) -> proper#(tail(X)) -> tail#(proper(X))
    top#(mark(X)) -> proper#(X) -> proper#(repItems(X)) -> proper#(X)
    top#(mark(X)) -> proper#(X) ->
    proper#(repItems(X)) -> repItems#(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))
    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#(s(X)) -> proper#(X)
    proper#(repItems(X)) -> proper#(X) ->
    proper#(s(X)) -> s#(proper(X))
    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#(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#(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#(tail(X)) -> proper#(X)
    proper#(repItems(X)) -> proper#(X) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(repItems(X)) -> proper#(X) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(repItems(X)) -> proper#(X) ->
    proper#(repItems(X)) -> repItems#(proper(X))
    proper#(repItems(X)) -> repItems#(proper(X)) ->
    repItems#(mark(X)) -> repItems#(X)
    proper#(repItems(X)) -> repItems#(proper(X)) ->
    repItems#(ok(X)) -> repItems#(X)
    proper#(tail(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(tail(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(tail(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(tail(X)) -> proper#(X) -> proper#(incr(X)) -> proper#(X)
    proper#(tail(X)) -> proper#(X) ->
    proper#(incr(X)) -> incr#(proper(X))
    proper#(tail(X)) -> proper#(X) -> proper#(s(X)) -> proper#(X)
    proper#(tail(X)) -> proper#(X) -> proper#(s(X)) -> s#(proper(X))
    proper#(tail(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(tail(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(tail(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(tail(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(tail(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(tail(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(tail(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(tail(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(tail(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(tail(X)) -> proper#(X) -> proper#(tail(X)) -> proper#(X)
    proper#(tail(X)) -> proper#(X) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(tail(X)) -> proper#(X) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(tail(X)) -> proper#(X) ->
    proper#(repItems(X)) -> repItems#(proper(X))
    proper#(tail(X)) -> tail#(proper(X)) ->
    tail#(mark(X)) -> tail#(X)
    proper#(tail(X)) -> tail#(proper(X)) ->
    tail#(ok(X)) -> tail#(X)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(incr(X)) -> proper#(X)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(incr(X)) -> incr#(proper(X))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(s(X)) -> proper#(X)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(s(X)) -> s#(proper(X))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(tail(X)) -> proper#(X)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(pair(X1,X2)) -> proper#(X2) ->
    proper#(repItems(X)) -> repItems#(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))
    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#(s(X)) -> proper#(X)
    proper#(pair(X1,X2)) -> proper#(X1) ->
    proper#(s(X)) -> s#(proper(X))
    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#(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#(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#(tail(X)) -> proper#(X)
    proper#(pair(X1,X2)) -> proper#(X1) ->
    proper#(tail(X)) -> tail#(proper(X))
    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)) -> pair#(proper(X1),proper(X2)) ->
    pair#(mark(X1),X2) -> pair#(X1,X2)
    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#(ok(X1),ok(X2)) -> pair#(X1,X2)
    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))
    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#(s(X)) -> proper#(X)
    proper#(zip(X1,X2)) -> proper#(X2) ->
    proper#(s(X)) -> s#(proper(X))
    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#(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#(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#(tail(X)) -> proper#(X)
    proper#(zip(X1,X2)) -> proper#(X2) ->
    proper#(tail(X)) -> tail#(proper(X))
    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#(X1) ->
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(incr(X)) -> proper#(X)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(incr(X)) -> incr#(proper(X))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(s(X)) -> proper#(X)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(s(X)) -> s#(proper(X))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(tail(X)) -> proper#(X)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(zip(X1,X2)) -> proper#(X1) ->
    proper#(repItems(X)) -> repItems#(proper(X))
    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)
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2)) ->
    zip#(ok(X1),ok(X2)) -> zip#(X1,X2)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(incr(X)) -> proper#(X)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(incr(X)) -> incr#(proper(X))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(s(X)) -> proper#(X)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(s(X)) -> s#(proper(X))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(tail(X)) -> proper#(X)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(take(X1,X2)) -> proper#(X2) ->
    proper#(repItems(X)) -> repItems#(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#(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#(s(X)) -> proper#(X)
    proper#(take(X1,X2)) -> proper#(X1) ->
    proper#(s(X)) -> s#(proper(X))
    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#(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#(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#(tail(X)) -> proper#(X)
    proper#(take(X1,X2)) -> proper#(X1) ->
    proper#(tail(X)) -> tail#(proper(X))
    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)) -> take#(proper(X1),proper(X2)) ->
    take#(mark(X1),X2) -> take#(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#(ok(X1),ok(X2)) -> take#(X1,X2)
    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#(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#(s(X)) -> proper#(X)
    proper#(s(X)) -> proper#(X) -> proper#(s(X)) -> s#(proper(X))
    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#(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#(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#(tail(X)) -> proper#(X)
    proper#(s(X)) -> proper#(X) -> proper#(tail(X)) -> tail#(proper(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)) -> s#(proper(X)) -> s#(mark(X)) -> s#(X)
    proper#(s(X)) -> s#(proper(X)) -> s#(ok(X)) -> s#(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#(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#(s(X)) -> proper#(X)
    proper#(cons(X1,X2)) -> proper#(X2) ->
    proper#(s(X)) -> s#(proper(X))
    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#(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#(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#(tail(X)) -> proper#(X)
    proper#(cons(X1,X2)) -> proper#(X2) ->
    proper#(tail(X)) -> tail#(proper(X))
    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#(X1) ->
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(incr(X)) -> proper#(X)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(incr(X)) -> incr#(proper(X))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(s(X)) -> proper#(X)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(s(X)) -> s#(proper(X))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(tail(X)) -> proper#(X)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(cons(X1,X2)) -> proper#(X1) ->
    proper#(repItems(X)) -> repItems#(proper(X))
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2)) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2)) ->
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
    proper#(incr(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> proper#(X2)
    proper#(incr(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> proper#(X1)
    proper#(incr(X)) -> proper#(X) ->
    proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
    proper#(incr(X)) -> proper#(X) -> proper#(incr(X)) -> proper#(X)
    proper#(incr(X)) -> proper#(X) ->
    proper#(incr(X)) -> incr#(proper(X))
    proper#(incr(X)) -> proper#(X) -> proper#(s(X)) -> proper#(X)
    proper#(incr(X)) -> proper#(X) -> proper#(s(X)) -> s#(proper(X))
    proper#(incr(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> proper#(X2)
    proper#(incr(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> proper#(X1)
    proper#(incr(X)) -> proper#(X) ->
    proper#(take(X1,X2)) -> take#(proper(X1),proper(X2))
    proper#(incr(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> proper#(X2)
    proper#(incr(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> proper#(X1)
    proper#(incr(X)) -> proper#(X) ->
    proper#(zip(X1,X2)) -> zip#(proper(X1),proper(X2))
    proper#(incr(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> proper#(X2)
    proper#(incr(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> proper#(X1)
    proper#(incr(X)) -> proper#(X) ->
    proper#(pair(X1,X2)) -> pair#(proper(X1),proper(X2))
    proper#(incr(X)) -> proper#(X) -> proper#(tail(X)) -> proper#(X)
    proper#(incr(X)) -> proper#(X) ->
    proper#(tail(X)) -> tail#(proper(X))
    proper#(incr(X)) -> proper#(X) ->
    proper#(repItems(X)) -> proper#(X)
    proper#(incr(X)) -> proper#(X) ->
    proper#(repItems(X)) -> repItems#(proper(X))
    proper#(incr(X)) -> incr#(proper(X)) ->
    incr#(mark(X)) -> incr#(X)
    proper#(incr(X)) -> incr#(proper(X)) -> incr#(ok(X)) -> incr#(X)
    tail#(ok(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X)
    tail#(ok(X)) -> tail#(X) -> tail#(ok(X)) -> tail#(X)
    tail#(mark(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X)
    tail#(mark(X)) -> tail#(X) -> tail#(ok(X)) -> tail#(X)
    repItems#(ok(X)) -> repItems#(X) ->
    repItems#(mark(X)) -> repItems#(X)
    repItems#(ok(X)) -> repItems#(X) ->
    repItems#(ok(X)) -> repItems#(X)
    repItems#(mark(X)) -> repItems#(X) ->
    repItems#(mark(X)) -> repItems#(X)
    repItems#(mark(X)) -> repItems#(X) ->
    repItems#(ok(X)) -> repItems#(X)
    pair#(ok(X1),ok(X2)) -> pair#(X1,X2) ->
    pair#(mark(X1),X2) -> pair#(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#(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)
    pair#(mark(X1),X2) -> pair#(X1,X2) ->
    pair#(ok(X1),ok(X2)) -> pair#(X1,X2)
    pair#(X1,mark(X2)) -> pair#(X1,X2) ->
    pair#(mark(X1),X2) -> pair#(X1,X2)
    pair#(X1,mark(X2)) -> pair#(X1,X2) ->
    pair#(X1,mark(X2)) -> pair#(X1,X2)
    pair#(X1,mark(X2)) -> pair#(X1,X2) ->
    pair#(ok(X1),ok(X2)) -> pair#(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)
    zip#(ok(X1),ok(X2)) -> zip#(X1,X2) ->
    zip#(ok(X1),ok(X2)) -> zip#(X1,X2)
    zip#(mark(X1),X2) -> zip#(X1,X2) ->
    zip#(mark(X1),X2) -> zip#(X1,X2)
    zip#(mark(X1),X2) -> zip#(X1,X2) ->
    zip#(X1,mark(X2)) -> zip#(X1,X2)
    zip#(mark(X1),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#(X1,mark(X2)) -> zip#(X1,X2) ->
    zip#(ok(X1),ok(X2)) -> zip#(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#(X1,mark(X2)) -> take#(X1,X2)
    take#(ok(X1),ok(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)
    take#(mark(X1),X2) -> take#(X1,X2) ->
    take#(ok(X1),ok(X2)) -> take#(X1,X2)
    take#(X1,mark(X2)) -> take#(X1,X2) ->
    take#(mark(X1),X2) -> take#(X1,X2)
    take#(X1,mark(X2)) -> take#(X1,X2) ->
    take#(X1,mark(X2)) -> take#(X1,X2)
    take#(X1,mark(X2)) -> take#(X1,X2) -> take#(ok(X1),ok(X2)) -> take#(X1,X2)
    s#(ok(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(ok(X)) -> s#(X) -> s#(ok(X)) -> s#(X)
    s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(mark(X)) -> s#(X) -> s#(ok(X)) -> s#(X)
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2) ->
    cons#(mark(X1),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) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(mark(X1),X2) -> cons#(X1,X2) ->
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
    incr#(ok(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X)
    incr#(ok(X)) -> incr#(X) -> incr#(ok(X)) -> incr#(X)
    incr#(mark(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X)
    incr#(mark(X)) -> incr#(X) ->
    incr#(ok(X)) -> incr#(X)
    active#(repItems(cons(X,XS))) -> repItems#(XS) ->
    repItems#(mark(X)) -> repItems#(X)
    active#(repItems(cons(X,XS))) -> repItems#(XS) ->
    repItems#(ok(X)) -> repItems#(X)
    active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) ->
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
    active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) ->
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
    active#(repItems(X)) -> repItems#(active(X)) ->
    repItems#(mark(X)) -> repItems#(X)
    active#(repItems(X)) -> repItems#(active(X)) ->
    repItems#(ok(X)) -> repItems#(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))) -> incr#(XS)
    active#(repItems(X)) -> active#(X) ->
    active#(incr(cons(X,XS))) -> s#(X)
    active#(repItems(X)) -> active#(X) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    active#(repItems(X)) -> active#(X) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    active#(repItems(X)) -> active#(X) ->
    active#(s(X)) -> s#(active(X))
    active#(repItems(X)) -> active#(X) ->
    active#(take(X1,X2)) -> active#(X1)
    active#(repItems(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(repItems(X)) -> active#(X) ->
    active#(take(X1,X2)) -> active#(X2)
    active#(repItems(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(repItems(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> active#(X1)
    active#(repItems(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(repItems(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> active#(X2)
    active#(repItems(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(repItems(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> active#(X1)
    active#(repItems(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(repItems(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> active#(X2)
    active#(repItems(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(repItems(X)) -> active#(X) ->
    active#(tail(X)) -> active#(X)
    active#(repItems(X)) -> active#(X) ->
    active#(tail(X)) -> tail#(active(X))
    active#(repItems(X)) -> active#(X) ->
    active#(repItems(X)) -> active#(X)
    active#(repItems(X)) -> active#(X) ->
    active#(repItems(X)) -> repItems#(active(X))
    active#(tail(X)) -> tail#(active(X)) ->
    tail#(mark(X)) -> tail#(X)
    active#(tail(X)) -> tail#(active(X)) -> tail#(ok(X)) -> tail#(X)
    active#(tail(X)) -> active#(X) ->
    active#(pairNs()) -> incr#(oddNs())
    active#(tail(X)) -> active#(X) ->
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(tail(X)) -> active#(X) ->
    active#(oddNs()) -> incr#(pairNs())
    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#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    active#(tail(X)) -> active#(X) ->
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    active#(tail(X)) -> active#(X) ->
    active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
    active#(tail(X)) -> active#(X) ->
    active#(repItems(cons(X,XS))) -> 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))) -> cons#(X,cons(X,repItems(XS)))
    active#(tail(X)) -> active#(X) ->
    active#(cons(X1,X2)) -> active#(X1)
    active#(tail(X)) -> active#(X) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    active#(tail(X)) -> active#(X) -> active#(incr(X)) -> active#(X)
    active#(tail(X)) -> active#(X) ->
    active#(incr(X)) -> incr#(active(X))
    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)) -> take#(active(X1),X2)
    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#(zip(X1,X2)) -> active#(X1)
    active#(tail(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    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#(pair(X1,X2)) -> active#(X1)
    active#(tail(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    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#(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#(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#(pair(X1,X2)) -> pair#(X1,active(X2)) ->
    pair#(X1,mark(X2)) -> pair#(X1,X2)
    active#(pair(X1,X2)) -> pair#(X1,active(X2)) ->
    pair#(ok(X1),ok(X2)) -> pair#(X1,X2)
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(pairNs()) -> incr#(oddNs())
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(oddNs()) -> incr#(pairNs())
    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#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    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#(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#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(repItems(cons(X,XS))) -> 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))) -> cons#(X,cons(X,repItems(XS)))
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(cons(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(incr(X)) -> active#(X)
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(incr(X)) -> incr#(active(X))
    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)) -> take#(active(X1),X2)
    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#(zip(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    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#(pair(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X2) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    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#(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#(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))) -> incr#(XS)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(incr(cons(X,XS))) -> s#(X)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(s(X)) -> s#(active(X))
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> active#(X2)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> active#(X2)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> active#(X1)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> active#(X2)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(tail(X)) -> active#(X)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(tail(X)) -> tail#(active(X))
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(repItems(X)) -> active#(X)
    active#(pair(X1,X2)) -> active#(X1) ->
    active#(repItems(X)) -> repItems#(active(X))
    active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) ->
    pair#(ok(X1),ok(X2)) -> pair#(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#(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))) -> 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)
    active#(zip(X1,X2)) -> zip#(active(X1),X2) ->
    zip#(mark(X1),X2) -> zip#(X1,X2)
    active#(zip(X1,X2)) -> zip#(active(X1),X2) ->
    zip#(ok(X1),ok(X2)) -> zip#(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#(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))) -> incr#(XS)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(incr(cons(X,XS))) -> s#(X)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(s(X)) -> s#(active(X))
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(take(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(take(X1,X2)) -> active#(X2)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(zip(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(zip(X1,X2)) -> active#(X2)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(pair(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(pair(X1,X2)) -> active#(X2)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(tail(X)) -> active#(X)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(tail(X)) -> tail#(active(X))
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(repItems(X)) -> active#(X)
    active#(zip(X1,X2)) -> active#(X2) ->
    active#(repItems(X)) -> repItems#(active(X))
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(pairNs()) -> incr#(oddNs())
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(oddNs()) -> incr#(pairNs())
    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#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    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#(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#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(repItems(cons(X,XS))) -> 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))) -> cons#(X,cons(X,repItems(XS)))
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(cons(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(incr(X)) -> active#(X)
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(incr(X)) -> incr#(active(X))
    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)) -> take#(active(X1),X2)
    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#(zip(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    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#(pair(X1,X2)) -> active#(X1)
    active#(zip(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    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#(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#(take(s(N),cons(X,XS))) -> take#(N,XS) ->
    take#(X1,mark(X2)) -> take#(X1,X2)
    active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS)) ->
    cons#(ok(X1),ok(X2)) -> cons#(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)
    active#(take(X1,X2)) -> take#(X1,active(X2)) ->
    take#(X1,mark(X2)) -> take#(X1,X2)
    active#(take(X1,X2)) -> take#(X1,active(X2)) ->
    take#(ok(X1),ok(X2)) -> take#(X1,X2)
    active#(take(X1,X2)) -> active#(X2) ->
    active#(pairNs()) -> incr#(oddNs())
    active#(take(X1,X2)) -> active#(X2) ->
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(take(X1,X2)) -> active#(X2) ->
    active#(oddNs()) -> incr#(pairNs())
    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#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    active#(take(X1,X2)) -> active#(X2) ->
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    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#(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#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
    active#(take(X1,X2)) -> active#(X2) ->
    active#(repItems(cons(X,XS))) -> 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))) -> cons#(X,cons(X,repItems(XS)))
    active#(take(X1,X2)) -> active#(X2) ->
    active#(cons(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X2) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    active#(take(X1,X2)) -> active#(X2) ->
    active#(incr(X)) -> active#(X)
    active#(take(X1,X2)) -> active#(X2) ->
    active#(incr(X)) -> incr#(active(X))
    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)) -> take#(active(X1),X2)
    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#(zip(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X2) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    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#(pair(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X2) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    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#(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#(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))) -> incr#(XS)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(incr(cons(X,XS))) -> s#(X)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(s(X)) -> s#(active(X))
    active#(take(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> active#(X2)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(take(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> active#(X2)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(take(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> active#(X1)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> active#(X2)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(take(X1,X2)) -> active#(X1) ->
    active#(tail(X)) -> active#(X)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(tail(X)) -> tail#(active(X))
    active#(take(X1,X2)) -> active#(X1) ->
    active#(repItems(X)) -> active#(X)
    active#(take(X1,X2)) -> active#(X1) ->
    active#(repItems(X)) -> repItems#(active(X))
    active#(s(X)) -> s#(active(X)) -> s#(mark(X)) -> s#(X)
    active#(s(X)) -> s#(active(X)) -> s#(ok(X)) -> s#(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))) -> incr#(XS)
    active#(s(X)) -> active#(X) -> active#(incr(cons(X,XS))) -> s#(X)
    active#(s(X)) -> active#(X) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    active#(s(X)) -> active#(X) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    active#(s(X)) -> active#(X) -> active#(s(X)) -> s#(active(X))
    active#(s(X)) -> active#(X) -> active#(take(X1,X2)) -> active#(X1)
    active#(s(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(s(X)) -> active#(X) -> active#(take(X1,X2)) -> active#(X2)
    active#(s(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(s(X)) -> active#(X) -> active#(zip(X1,X2)) -> active#(X1)
    active#(s(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(s(X)) -> active#(X) -> active#(zip(X1,X2)) -> active#(X2)
    active#(s(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(s(X)) -> active#(X) -> active#(pair(X1,X2)) -> active#(X1)
    active#(s(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(s(X)) -> active#(X) -> active#(pair(X1,X2)) -> active#(X2)
    active#(s(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(s(X)) -> active#(X) -> active#(tail(X)) -> active#(X)
    active#(s(X)) -> active#(X) -> active#(tail(X)) -> tail#(active(X))
    active#(s(X)) -> active#(X) -> active#(repItems(X)) -> active#(X)
    active#(s(X)) -> active#(X) ->
    active#(repItems(X)) -> repItems#(active(X))
    active#(cons(X1,X2)) -> cons#(active(X1),X2) ->
    cons#(mark(X1),X2) -> cons#(X1,X2)
    active#(cons(X1,X2)) -> cons#(active(X1),X2) ->
    cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(pairNs()) -> incr#(oddNs())
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(oddNs()) -> incr#(pairNs())
    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#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    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#(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#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(repItems(cons(X,XS))) -> 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))) -> cons#(X,cons(X,repItems(XS)))
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(cons(X1,X2)) -> active#(X1)
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(incr(X)) -> active#(X)
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(incr(X)) -> incr#(active(X))
    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)) -> take#(active(X1),X2)
    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#(zip(X1,X2)) -> active#(X1)
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    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#(pair(X1,X2)) -> active#(X1)
    active#(cons(X1,X2)) -> active#(X1) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    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#(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#(incr(cons(X,XS))) -> s#(X) -> s#(ok(X)) -> s#(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)
    active#(incr(X)) -> incr#(active(X)) ->
    incr#(mark(X)) -> incr#(X)
    active#(incr(X)) -> incr#(active(X)) -> incr#(ok(X)) -> incr#(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))) -> incr#(XS)
    active#(incr(X)) -> active#(X) ->
    active#(incr(cons(X,XS))) -> s#(X)
    active#(incr(X)) -> active#(X) ->
    active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
    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#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
    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))) -> cons#(pair(X,Y),zip(XS,YS))
    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#(cons(X1,X2)) -> active#(X1)
    active#(incr(X)) -> active#(X) ->
    active#(cons(X1,X2)) -> cons#(active(X1),X2)
    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#(s(X)) -> active#(X)
    active#(incr(X)) -> active#(X) -> active#(s(X)) -> s#(active(X))
    active#(incr(X)) -> active#(X) ->
    active#(take(X1,X2)) -> active#(X1)
    active#(incr(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(active(X1),X2)
    active#(incr(X)) -> active#(X) ->
    active#(take(X1,X2)) -> active#(X2)
    active#(incr(X)) -> active#(X) ->
    active#(take(X1,X2)) -> take#(X1,active(X2))
    active#(incr(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> active#(X1)
    active#(incr(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(active(X1),X2)
    active#(incr(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> active#(X2)
    active#(incr(X)) -> active#(X) ->
    active#(zip(X1,X2)) -> zip#(X1,active(X2))
    active#(incr(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> active#(X1)
    active#(incr(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(active(X1),X2)
    active#(incr(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> active#(X2)
    active#(incr(X)) -> active#(X) ->
    active#(pair(X1,X2)) -> pair#(X1,active(X2))
    active#(incr(X)) -> active#(X) -> active#(tail(X)) -> active#(X)
    active#(incr(X)) -> active#(X) ->
    active#(tail(X)) -> tail#(active(X))
    active#(incr(X)) -> active#(X) ->
    active#(repItems(X)) -> active#(X)
    active#(incr(X)) -> active#(X) -> active#(repItems(X)) -> repItems#(active(X))
   SCC Processor:
    #sccs: 11
    #rules: 44
    #arcs: 803/6241
    DPs:
     top#(ok(X)) -> top#(active(X))
     top#(mark(X)) -> top#(proper(X))
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Open
    
    DPs:
     proper#(repItems(X)) -> proper#(X)
     proper#(tail(X)) -> proper#(X)
     proper#(pair(X1,X2)) -> proper#(X1)
     proper#(pair(X1,X2)) -> proper#(X2)
     proper#(zip(X1,X2)) -> proper#(X1)
     proper#(zip(X1,X2)) -> proper#(X2)
     proper#(take(X1,X2)) -> proper#(X1)
     proper#(take(X1,X2)) -> proper#(X2)
     proper#(s(X)) -> proper#(X)
     proper#(incr(X)) -> proper#(X)
     proper#(cons(X1,X2)) -> proper#(X1)
     proper#(cons(X1,X2)) -> proper#(X2)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [proper#](x0) = x0 + 1,
      
      [top](x0) = 0,
      
      [ok](x0) = x0,
      
      [proper](x0) = x0,
      
      [repItems](x0) = x0 + 1,
      
      [tail](x0) = x0,
      
      [pair](x0, x1) = x0 + x1,
      
      [zip](x0, x1) = x0 + x1 + 1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0 + x1,
      
      [s](x0) = x0,
      
      [mark](x0) = 0,
      
      [cons](x0, x1) = x0 + x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 1,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      proper#(repItems(X)) = X + 2 >= X + 1 = proper#(X)
      
      proper#(tail(X)) = X + 1 >= X + 1 = proper#(X)
      
      proper#(pair(X1,X2)) = X1 + X2 + 1 >= X1 + 1 = proper#(X1)
      
      proper#(pair(X1,X2)) = X1 + X2 + 1 >= X2 + 1 = proper#(X2)
      
      proper#(zip(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = proper#(X1)
      
      proper#(zip(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = proper#(X2)
      
      proper#(take(X1,X2)) = X1 + X2 + 1 >= X1 + 1 = proper#(X1)
      
      proper#(take(X1,X2)) = X1 + X2 + 1 >= X2 + 1 = proper#(X2)
      
      proper#(s(X)) = X + 1 >= X + 1 = proper#(X)
      
      proper#(incr(X)) = X + 1 >= X + 1 = proper#(X)
      
      proper#(cons(X1,X2)) = X1 + X2 + 1 >= X1 + 1 = proper#(X1)
      
      proper#(cons(X1,X2)) = X1 + X2 + 1 >= X2 + 1 = proper#(X2)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = X + XS >= 0 = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = XS + 1 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N + X + XS >= 0 = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS + 1 >= 0 = mark(nil())
      
      active(zip(X,nil())) = X + 1 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = X + XS + Y + YS + 1 >= 0 = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = X + XS >= 0 = mark(XS)
      
      active(repItems(nil())) = 1 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = X + XS + 1 >= 0 = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(X1,active(X2))
      
      active(tail(X)) = X >= X = tail(active(X))
      
      active(repItems(X)) = X + 1 >= X + 1 = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= 0 = mark(cons(X1,X2))
      
      incr(mark(X)) = 0 >= 0 = mark(incr(X))
      
      s(mark(X)) = 0 >= 0 = mark(s(X))
      
      take(mark(X1),X2) = X2 >= 0 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= 0 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 + 1 >= 0 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X1 + 1 >= 0 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= 0 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X1 >= 0 = mark(pair(X1,X2))
      
      tail(mark(X)) = 0 >= 0 = mark(tail(X))
      
      repItems(mark(X)) = 1 >= 0 = mark(repItems(X))
      
      proper(pairNs()) = 0 >= 0 = ok(pairNs())
      
      proper(cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(proper(X1),proper(X2))
      
      proper(0()) = 1 >= 1 = ok(0())
      
      proper(incr(X)) = X >= X = incr(proper(X))
      
      proper(oddNs()) = 0 >= 0 = ok(oddNs())
      
      proper(s(X)) = X >= X = s(proper(X))
      
      proper(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(proper(X1),proper(X2))
      
      proper(nil()) = 0 >= 0 = ok(nil())
      
      proper(zip(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X >= X = tail(proper(X))
      
      proper(repItems(X)) = X + 1 >= X + 1 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(cons(X1,X2))
      
      incr(ok(X)) = X >= X = ok(incr(X))
      
      s(ok(X)) = X >= X = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(pair(X1,X2))
      
      tail(ok(X)) = X >= X = ok(tail(X))
      
      repItems(ok(X)) = X + 1 >= X + 1 = ok(repItems(X))
      
      top(mark(X)) = 0 >= 0 = top(proper(X))
      
      top(ok(X)) = 0 >= 0 = top(active(X))
     problem:
      DPs:
       proper#(tail(X)) -> proper#(X)
       proper#(pair(X1,X2)) -> proper#(X1)
       proper#(pair(X1,X2)) -> proper#(X2)
       proper#(take(X1,X2)) -> proper#(X1)
       proper#(take(X1,X2)) -> proper#(X2)
       proper#(s(X)) -> proper#(X)
       proper#(incr(X)) -> proper#(X)
       proper#(cons(X1,X2)) -> proper#(X1)
       proper#(cons(X1,X2)) -> proper#(X2)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [proper#](x0) = x0 + 1,
       
       [top](x0) = 0,
       
       [ok](x0) = x0,
       
       [proper](x0) = x0,
       
       [repItems](x0) = 1,
       
       [tail](x0) = x0 + 1,
       
       [pair](x0, x1) = x0 + x1 + 1,
       
       [zip](x0, x1) = 1,
       
       [nil] = 0,
       
       [take](x0, x1) = x0 + x1 + 1,
       
       [s](x0) = x0 + 1,
       
       [mark](x0) = 1,
       
       [cons](x0, x1) = x0 + x1 + 1,
       
       [incr](x0) = x0 + 1,
       
       [oddNs] = 1,
       
       [0] = 0,
       
       [active](x0) = x0,
       
       [pairNs] = 1
      orientation:
       proper#(tail(X)) = X + 2 >= X + 1 = proper#(X)
       
       proper#(pair(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = proper#(X1)
       
       proper#(pair(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = proper#(X2)
       
       proper#(take(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = proper#(X1)
       
       proper#(take(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = proper#(X2)
       
       proper#(s(X)) = X + 2 >= X + 1 = proper#(X)
       
       proper#(incr(X)) = X + 2 >= X + 1 = proper#(X)
       
       proper#(cons(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = proper#(X1)
       
       proper#(cons(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = proper#(X2)
       
       active(pairNs()) = 1 >= 1 = mark(cons(0(),incr(oddNs())))
       
       active(oddNs()) = 1 >= 1 = mark(incr(pairNs()))
       
       active(incr(cons(X,XS))) = X + XS + 2 >= 1 = mark(cons(s(X),incr(XS)))
       
       active(take(0(),XS)) = XS + 1 >= 1 = mark(nil())
       
       active(take(s(N),cons(X,XS))) = N + X + XS + 3 >= 1 = mark(cons(X,take(N,XS)))
       
       active(zip(nil(),XS)) = 1 >= 1 = mark(nil())
       
       active(zip(X,nil())) = 1 >= 1 = mark(nil())
       
       active(zip(cons(X,XS),cons(Y,YS))) = 1 >= 1 = mark(cons(pair(X,Y),zip(XS,YS)))
       
       active(tail(cons(X,XS))) = X + XS + 2 >= 1 = mark(XS)
       
       active(repItems(nil())) = 1 >= 1 = mark(nil())
       
       active(repItems(cons(X,XS))) = 1 >= 1 = mark(cons(X,cons(X,repItems(XS))))
       
       active(cons(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = cons(active(X1),X2)
       
       active(incr(X)) = X + 1 >= X + 1 = incr(active(X))
       
       active(s(X)) = X + 1 >= X + 1 = s(active(X))
       
       active(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(active(X1),X2)
       
       active(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(X1,active(X2))
       
       active(zip(X1,X2)) = 1 >= 1 = zip(active(X1),X2)
       
       active(zip(X1,X2)) = 1 >= 1 = zip(X1,active(X2))
       
       active(pair(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = pair(active(X1),X2)
       
       active(pair(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = pair(X1,active(X2))
       
       active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
       
       active(repItems(X)) = 1 >= 1 = repItems(active(X))
       
       cons(mark(X1),X2) = X2 + 2 >= 1 = mark(cons(X1,X2))
       
       incr(mark(X)) = 2 >= 1 = mark(incr(X))
       
       s(mark(X)) = 2 >= 1 = mark(s(X))
       
       take(mark(X1),X2) = X2 + 2 >= 1 = mark(take(X1,X2))
       
       take(X1,mark(X2)) = X1 + 2 >= 1 = mark(take(X1,X2))
       
       zip(mark(X1),X2) = 1 >= 1 = mark(zip(X1,X2))
       
       zip(X1,mark(X2)) = 1 >= 1 = mark(zip(X1,X2))
       
       pair(mark(X1),X2) = X2 + 2 >= 1 = mark(pair(X1,X2))
       
       pair(X1,mark(X2)) = X1 + 2 >= 1 = mark(pair(X1,X2))
       
       tail(mark(X)) = 2 >= 1 = mark(tail(X))
       
       repItems(mark(X)) = 1 >= 1 = mark(repItems(X))
       
       proper(pairNs()) = 1 >= 1 = ok(pairNs())
       
       proper(cons(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = cons(proper(X1),proper(X2))
       
       proper(0()) = 0 >= 0 = ok(0())
       
       proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
       
       proper(oddNs()) = 1 >= 1 = ok(oddNs())
       
       proper(s(X)) = X + 1 >= X + 1 = s(proper(X))
       
       proper(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(proper(X1),proper(X2))
       
       proper(nil()) = 0 >= 0 = ok(nil())
       
       proper(zip(X1,X2)) = 1 >= 1 = zip(proper(X1),proper(X2))
       
       proper(pair(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = pair(proper(X1),proper(X2))
       
       proper(tail(X)) = X + 1 >= X + 1 = tail(proper(X))
       
       proper(repItems(X)) = 1 >= 1 = repItems(proper(X))
       
       cons(ok(X1),ok(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = ok(cons(X1,X2))
       
       incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
       
       s(ok(X)) = X + 1 >= X + 1 = ok(s(X))
       
       take(ok(X1),ok(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = ok(take(X1,X2))
       
       zip(ok(X1),ok(X2)) = 1 >= 1 = ok(zip(X1,X2))
       
       pair(ok(X1),ok(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = ok(pair(X1,X2))
       
       tail(ok(X)) = X + 1 >= X + 1 = ok(tail(X))
       
       repItems(ok(X)) = 1 >= 1 = ok(repItems(X))
       
       top(mark(X)) = 0 >= 0 = top(proper(X))
       
       top(ok(X)) = 0 >= 0 = top(active(X))
      problem:
       DPs:
        
       TRS:
        active(pairNs()) -> mark(cons(0(),incr(oddNs())))
        active(oddNs()) -> mark(incr(pairNs()))
        active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
        active(take(0(),XS)) -> mark(nil())
        active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
        active(zip(nil(),XS)) -> mark(nil())
        active(zip(X,nil())) -> mark(nil())
        active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
        active(tail(cons(X,XS))) -> mark(XS)
        active(repItems(nil())) -> mark(nil())
        active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
        active(cons(X1,X2)) -> cons(active(X1),X2)
        active(incr(X)) -> incr(active(X))
        active(s(X)) -> s(active(X))
        active(take(X1,X2)) -> take(active(X1),X2)
        active(take(X1,X2)) -> take(X1,active(X2))
        active(zip(X1,X2)) -> zip(active(X1),X2)
        active(zip(X1,X2)) -> zip(X1,active(X2))
        active(pair(X1,X2)) -> pair(active(X1),X2)
        active(pair(X1,X2)) -> pair(X1,active(X2))
        active(tail(X)) -> tail(active(X))
        active(repItems(X)) -> repItems(active(X))
        cons(mark(X1),X2) -> mark(cons(X1,X2))
        incr(mark(X)) -> mark(incr(X))
        s(mark(X)) -> mark(s(X))
        take(mark(X1),X2) -> mark(take(X1,X2))
        take(X1,mark(X2)) -> mark(take(X1,X2))
        zip(mark(X1),X2) -> mark(zip(X1,X2))
        zip(X1,mark(X2)) -> mark(zip(X1,X2))
        pair(mark(X1),X2) -> mark(pair(X1,X2))
        pair(X1,mark(X2)) -> mark(pair(X1,X2))
        tail(mark(X)) -> mark(tail(X))
        repItems(mark(X)) -> mark(repItems(X))
        proper(pairNs()) -> ok(pairNs())
        proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
        proper(0()) -> ok(0())
        proper(incr(X)) -> incr(proper(X))
        proper(oddNs()) -> ok(oddNs())
        proper(s(X)) -> s(proper(X))
        proper(take(X1,X2)) -> take(proper(X1),proper(X2))
        proper(nil()) -> ok(nil())
        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))
        cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
        incr(ok(X)) -> ok(incr(X))
        s(ok(X)) -> ok(s(X))
        take(ok(X1),ok(X2)) -> ok(take(X1,X2))
        zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
        pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
        tail(ok(X)) -> ok(tail(X))
        repItems(ok(X)) -> ok(repItems(X))
        top(mark(X)) -> top(proper(X))
        top(ok(X)) -> top(active(X))
      Qed
    
    DPs:
     active#(repItems(X)) -> active#(X)
     active#(tail(X)) -> active#(X)
     active#(pair(X1,X2)) -> active#(X2)
     active#(pair(X1,X2)) -> active#(X1)
     active#(zip(X1,X2)) -> active#(X2)
     active#(zip(X1,X2)) -> active#(X1)
     active#(take(X1,X2)) -> active#(X2)
     active#(take(X1,X2)) -> active#(X1)
     active#(s(X)) -> active#(X)
     active#(incr(X)) -> active#(X)
     active#(cons(X1,X2)) -> active#(X1)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [active#](x0) = x0,
      
      [top](x0) = 0,
      
      [ok](x0) = x0,
      
      [proper](x0) = x0,
      
      [repItems](x0) = x0,
      
      [tail](x0) = x0,
      
      [pair](x0, x1) = x0 + x1,
      
      [zip](x0, x1) = x0 + x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0 + x1,
      
      [s](x0) = x0,
      
      [mark](x0) = 0,
      
      [cons](x0, x1) = x0 + 1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 0,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      active#(repItems(X)) = X >= X = active#(X)
      
      active#(tail(X)) = X >= X = active#(X)
      
      active#(pair(X1,X2)) = X1 + X2 >= X2 = active#(X2)
      
      active#(pair(X1,X2)) = X1 + X2 >= X1 = active#(X1)
      
      active#(zip(X1,X2)) = X1 + X2 >= X2 = active#(X2)
      
      active#(zip(X1,X2)) = X1 + X2 >= X1 = active#(X1)
      
      active#(take(X1,X2)) = X1 + X2 >= X2 = active#(X2)
      
      active#(take(X1,X2)) = X1 + X2 >= X1 = active#(X1)
      
      active#(s(X)) = X >= X = active#(X)
      
      active#(incr(X)) = X >= X = active#(X)
      
      active#(cons(X1,X2)) = X1 + 1 >= X1 = active#(X1)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = X + 1 >= 0 = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = XS >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N + X + 1 >= 0 = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = X >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = X + Y + 2 >= 0 = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = X + 1 >= 0 = mark(XS)
      
      active(repItems(nil())) = 0 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = X + 1 >= 0 = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X1 + 1 >= X1 + 1 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(X1,active(X2))
      
      active(tail(X)) = X >= X = tail(active(X))
      
      active(repItems(X)) = X >= X = repItems(active(X))
      
      cons(mark(X1),X2) = 1 >= 0 = mark(cons(X1,X2))
      
      incr(mark(X)) = 0 >= 0 = mark(incr(X))
      
      s(mark(X)) = 0 >= 0 = mark(s(X))
      
      take(mark(X1),X2) = X2 >= 0 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= 0 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= 0 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X1 >= 0 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= 0 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X1 >= 0 = mark(pair(X1,X2))
      
      tail(mark(X)) = 0 >= 0 = mark(tail(X))
      
      repItems(mark(X)) = 0 >= 0 = mark(repItems(X))
      
      proper(pairNs()) = 0 >= 0 = ok(pairNs())
      
      proper(cons(X1,X2)) = X1 + 1 >= X1 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 0 >= 0 = ok(0())
      
      proper(incr(X)) = X >= X = incr(proper(X))
      
      proper(oddNs()) = 0 >= 0 = ok(oddNs())
      
      proper(s(X)) = X >= X = s(proper(X))
      
      proper(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(proper(X1),proper(X2))
      
      proper(nil()) = 0 >= 0 = ok(nil())
      
      proper(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X >= X = tail(proper(X))
      
      proper(repItems(X)) = X >= X = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X >= X = ok(incr(X))
      
      s(ok(X)) = X >= X = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(pair(X1,X2))
      
      tail(ok(X)) = X >= X = ok(tail(X))
      
      repItems(ok(X)) = X >= X = ok(repItems(X))
      
      top(mark(X)) = 0 >= 0 = top(proper(X))
      
      top(ok(X)) = 0 >= 0 = top(active(X))
     problem:
      DPs:
       active#(repItems(X)) -> active#(X)
       active#(tail(X)) -> active#(X)
       active#(pair(X1,X2)) -> active#(X2)
       active#(pair(X1,X2)) -> active#(X1)
       active#(zip(X1,X2)) -> active#(X2)
       active#(zip(X1,X2)) -> active#(X1)
       active#(take(X1,X2)) -> active#(X2)
       active#(take(X1,X2)) -> active#(X1)
       active#(s(X)) -> active#(X)
       active#(incr(X)) -> active#(X)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [active#](x0) = x0,
       
       [top](x0) = 0,
       
       [ok](x0) = 0,
       
       [proper](x0) = x0,
       
       [repItems](x0) = x0,
       
       [tail](x0) = x0,
       
       [pair](x0, x1) = x0 + x1,
       
       [zip](x0, x1) = x0 + x1,
       
       [nil] = 1,
       
       [take](x0, x1) = x0 + x1,
       
       [s](x0) = x0 + 1,
       
       [mark](x0) = 0,
       
       [cons](x0, x1) = 0,
       
       [incr](x0) = x0,
       
       [oddNs] = 1,
       
       [0] = 1,
       
       [active](x0) = x0,
       
       [pairNs] = 1
      orientation:
       active#(repItems(X)) = X >= X = active#(X)
       
       active#(tail(X)) = X >= X = active#(X)
       
       active#(pair(X1,X2)) = X1 + X2 >= X2 = active#(X2)
       
       active#(pair(X1,X2)) = X1 + X2 >= X1 = active#(X1)
       
       active#(zip(X1,X2)) = X1 + X2 >= X2 = active#(X2)
       
       active#(zip(X1,X2)) = X1 + X2 >= X1 = active#(X1)
       
       active#(take(X1,X2)) = X1 + X2 >= X2 = active#(X2)
       
       active#(take(X1,X2)) = X1 + X2 >= X1 = active#(X1)
       
       active#(s(X)) = X + 1 >= X = active#(X)
       
       active#(incr(X)) = X >= X = active#(X)
       
       active(pairNs()) = 1 >= 0 = mark(cons(0(),incr(oddNs())))
       
       active(oddNs()) = 1 >= 0 = mark(incr(pairNs()))
       
       active(incr(cons(X,XS))) = 0 >= 0 = mark(cons(s(X),incr(XS)))
       
       active(take(0(),XS)) = XS + 1 >= 0 = mark(nil())
       
       active(take(s(N),cons(X,XS))) = N + 1 >= 0 = mark(cons(X,take(N,XS)))
       
       active(zip(nil(),XS)) = XS + 1 >= 0 = mark(nil())
       
       active(zip(X,nil())) = X + 1 >= 0 = mark(nil())
       
       active(zip(cons(X,XS),cons(Y,YS))) = 0 >= 0 = mark(cons(pair(X,Y),zip(XS,YS)))
       
       active(tail(cons(X,XS))) = 0 >= 0 = mark(XS)
       
       active(repItems(nil())) = 1 >= 0 = mark(nil())
       
       active(repItems(cons(X,XS))) = 0 >= 0 = mark(cons(X,cons(X,repItems(XS))))
       
       active(cons(X1,X2)) = 0 >= 0 = cons(active(X1),X2)
       
       active(incr(X)) = X >= X = incr(active(X))
       
       active(s(X)) = X + 1 >= X + 1 = s(active(X))
       
       active(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(active(X1),X2)
       
       active(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(X1,active(X2))
       
       active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(active(X1),X2)
       
       active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(X1,active(X2))
       
       active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(active(X1),X2)
       
       active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(X1,active(X2))
       
       active(tail(X)) = X >= X = tail(active(X))
       
       active(repItems(X)) = X >= X = repItems(active(X))
       
       cons(mark(X1),X2) = 0 >= 0 = mark(cons(X1,X2))
       
       incr(mark(X)) = 0 >= 0 = mark(incr(X))
       
       s(mark(X)) = 1 >= 0 = mark(s(X))
       
       take(mark(X1),X2) = X2 >= 0 = mark(take(X1,X2))
       
       take(X1,mark(X2)) = X1 >= 0 = mark(take(X1,X2))
       
       zip(mark(X1),X2) = X2 >= 0 = mark(zip(X1,X2))
       
       zip(X1,mark(X2)) = X1 >= 0 = mark(zip(X1,X2))
       
       pair(mark(X1),X2) = X2 >= 0 = mark(pair(X1,X2))
       
       pair(X1,mark(X2)) = X1 >= 0 = mark(pair(X1,X2))
       
       tail(mark(X)) = 0 >= 0 = mark(tail(X))
       
       repItems(mark(X)) = 0 >= 0 = mark(repItems(X))
       
       proper(pairNs()) = 1 >= 0 = ok(pairNs())
       
       proper(cons(X1,X2)) = 0 >= 0 = cons(proper(X1),proper(X2))
       
       proper(0()) = 1 >= 0 = ok(0())
       
       proper(incr(X)) = X >= X = incr(proper(X))
       
       proper(oddNs()) = 1 >= 0 = ok(oddNs())
       
       proper(s(X)) = X + 1 >= X + 1 = s(proper(X))
       
       proper(take(X1,X2)) = X1 + X2 >= X1 + X2 = take(proper(X1),proper(X2))
       
       proper(nil()) = 1 >= 0 = ok(nil())
       
       proper(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(proper(X1),proper(X2))
       
       proper(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(proper(X1),proper(X2))
       
       proper(tail(X)) = X >= X = tail(proper(X))
       
       proper(repItems(X)) = X >= X = repItems(proper(X))
       
       cons(ok(X1),ok(X2)) = 0 >= 0 = ok(cons(X1,X2))
       
       incr(ok(X)) = 0 >= 0 = ok(incr(X))
       
       s(ok(X)) = 1 >= 0 = ok(s(X))
       
       take(ok(X1),ok(X2)) = 0 >= 0 = ok(take(X1,X2))
       
       zip(ok(X1),ok(X2)) = 0 >= 0 = ok(zip(X1,X2))
       
       pair(ok(X1),ok(X2)) = 0 >= 0 = ok(pair(X1,X2))
       
       tail(ok(X)) = 0 >= 0 = ok(tail(X))
       
       repItems(ok(X)) = 0 >= 0 = ok(repItems(X))
       
       top(mark(X)) = 0 >= 0 = top(proper(X))
       
       top(ok(X)) = 0 >= 0 = top(active(X))
      problem:
       DPs:
        active#(repItems(X)) -> active#(X)
        active#(tail(X)) -> active#(X)
        active#(pair(X1,X2)) -> active#(X2)
        active#(pair(X1,X2)) -> active#(X1)
        active#(zip(X1,X2)) -> active#(X2)
        active#(zip(X1,X2)) -> active#(X1)
        active#(take(X1,X2)) -> active#(X2)
        active#(take(X1,X2)) -> active#(X1)
        active#(incr(X)) -> active#(X)
       TRS:
        active(pairNs()) -> mark(cons(0(),incr(oddNs())))
        active(oddNs()) -> mark(incr(pairNs()))
        active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
        active(take(0(),XS)) -> mark(nil())
        active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
        active(zip(nil(),XS)) -> mark(nil())
        active(zip(X,nil())) -> mark(nil())
        active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
        active(tail(cons(X,XS))) -> mark(XS)
        active(repItems(nil())) -> mark(nil())
        active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
        active(cons(X1,X2)) -> cons(active(X1),X2)
        active(incr(X)) -> incr(active(X))
        active(s(X)) -> s(active(X))
        active(take(X1,X2)) -> take(active(X1),X2)
        active(take(X1,X2)) -> take(X1,active(X2))
        active(zip(X1,X2)) -> zip(active(X1),X2)
        active(zip(X1,X2)) -> zip(X1,active(X2))
        active(pair(X1,X2)) -> pair(active(X1),X2)
        active(pair(X1,X2)) -> pair(X1,active(X2))
        active(tail(X)) -> tail(active(X))
        active(repItems(X)) -> repItems(active(X))
        cons(mark(X1),X2) -> mark(cons(X1,X2))
        incr(mark(X)) -> mark(incr(X))
        s(mark(X)) -> mark(s(X))
        take(mark(X1),X2) -> mark(take(X1,X2))
        take(X1,mark(X2)) -> mark(take(X1,X2))
        zip(mark(X1),X2) -> mark(zip(X1,X2))
        zip(X1,mark(X2)) -> mark(zip(X1,X2))
        pair(mark(X1),X2) -> mark(pair(X1,X2))
        pair(X1,mark(X2)) -> mark(pair(X1,X2))
        tail(mark(X)) -> mark(tail(X))
        repItems(mark(X)) -> mark(repItems(X))
        proper(pairNs()) -> ok(pairNs())
        proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
        proper(0()) -> ok(0())
        proper(incr(X)) -> incr(proper(X))
        proper(oddNs()) -> ok(oddNs())
        proper(s(X)) -> s(proper(X))
        proper(take(X1,X2)) -> take(proper(X1),proper(X2))
        proper(nil()) -> ok(nil())
        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))
        cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
        incr(ok(X)) -> ok(incr(X))
        s(ok(X)) -> ok(s(X))
        take(ok(X1),ok(X2)) -> ok(take(X1,X2))
        zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
        pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
        tail(ok(X)) -> ok(tail(X))
        repItems(ok(X)) -> ok(repItems(X))
        top(mark(X)) -> top(proper(X))
        top(ok(X)) -> top(active(X))
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [active#](x0) = x0,
        
        [top](x0) = 0,
        
        [ok](x0) = x0,
        
        [proper](x0) = x0,
        
        [repItems](x0) = x0,
        
        [tail](x0) = x0,
        
        [pair](x0, x1) = x0 + x1,
        
        [zip](x0, x1) = x0 + x1,
        
        [nil] = 1,
        
        [take](x0, x1) = x0 + x1 + 1,
        
        [s](x0) = 1,
        
        [mark](x0) = 0,
        
        [cons](x0, x1) = x0,
        
        [incr](x0) = x0,
        
        [oddNs] = 1,
        
        [0] = 0,
        
        [active](x0) = x0,
        
        [pairNs] = 1
       orientation:
        active#(repItems(X)) = X >= X = active#(X)
        
        active#(tail(X)) = X >= X = active#(X)
        
        active#(pair(X1,X2)) = X1 + X2 >= X2 = active#(X2)
        
        active#(pair(X1,X2)) = X1 + X2 >= X1 = active#(X1)
        
        active#(zip(X1,X2)) = X1 + X2 >= X2 = active#(X2)
        
        active#(zip(X1,X2)) = X1 + X2 >= X1 = active#(X1)
        
        active#(take(X1,X2)) = X1 + X2 + 1 >= X2 = active#(X2)
        
        active#(take(X1,X2)) = X1 + X2 + 1 >= X1 = active#(X1)
        
        active#(incr(X)) = X >= X = active#(X)
        
        active(pairNs()) = 1 >= 0 = mark(cons(0(),incr(oddNs())))
        
        active(oddNs()) = 1 >= 0 = mark(incr(pairNs()))
        
        active(incr(cons(X,XS))) = X >= 0 = mark(cons(s(X),incr(XS)))
        
        active(take(0(),XS)) = XS + 1 >= 0 = mark(nil())
        
        active(take(s(N),cons(X,XS))) = X + 2 >= 0 = mark(cons(X,take(N,XS)))
        
        active(zip(nil(),XS)) = XS + 1 >= 0 = mark(nil())
        
        active(zip(X,nil())) = X + 1 >= 0 = mark(nil())
        
        active(zip(cons(X,XS),cons(Y,YS))) = X + Y >= 0 = mark(cons(pair(X,Y),zip(XS,YS)))
        
        active(tail(cons(X,XS))) = X >= 0 = mark(XS)
        
        active(repItems(nil())) = 1 >= 0 = mark(nil())
        
        active(repItems(cons(X,XS))) = X >= 0 = mark(cons(X,cons(X,repItems(XS))))
        
        active(cons(X1,X2)) = X1 >= X1 = cons(active(X1),X2)
        
        active(incr(X)) = X >= X = incr(active(X))
        
        active(s(X)) = 1 >= 1 = s(active(X))
        
        active(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(active(X1),X2)
        
        active(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(X1,active(X2))
        
        active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(active(X1),X2)
        
        active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(X1,active(X2))
        
        active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(active(X1),X2)
        
        active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(X1,active(X2))
        
        active(tail(X)) = X >= X = tail(active(X))
        
        active(repItems(X)) = X >= X = repItems(active(X))
        
        cons(mark(X1),X2) = 0 >= 0 = mark(cons(X1,X2))
        
        incr(mark(X)) = 0 >= 0 = mark(incr(X))
        
        s(mark(X)) = 1 >= 0 = mark(s(X))
        
        take(mark(X1),X2) = X2 + 1 >= 0 = mark(take(X1,X2))
        
        take(X1,mark(X2)) = X1 + 1 >= 0 = mark(take(X1,X2))
        
        zip(mark(X1),X2) = X2 >= 0 = mark(zip(X1,X2))
        
        zip(X1,mark(X2)) = X1 >= 0 = mark(zip(X1,X2))
        
        pair(mark(X1),X2) = X2 >= 0 = mark(pair(X1,X2))
        
        pair(X1,mark(X2)) = X1 >= 0 = mark(pair(X1,X2))
        
        tail(mark(X)) = 0 >= 0 = mark(tail(X))
        
        repItems(mark(X)) = 0 >= 0 = mark(repItems(X))
        
        proper(pairNs()) = 1 >= 1 = ok(pairNs())
        
        proper(cons(X1,X2)) = X1 >= X1 = cons(proper(X1),proper(X2))
        
        proper(0()) = 0 >= 0 = ok(0())
        
        proper(incr(X)) = X >= X = incr(proper(X))
        
        proper(oddNs()) = 1 >= 1 = ok(oddNs())
        
        proper(s(X)) = 1 >= 1 = s(proper(X))
        
        proper(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(proper(X1),proper(X2))
        
        proper(nil()) = 1 >= 1 = ok(nil())
        
        proper(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(proper(X1),proper(X2))
        
        proper(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(proper(X1),proper(X2))
        
        proper(tail(X)) = X >= X = tail(proper(X))
        
        proper(repItems(X)) = X >= X = repItems(proper(X))
        
        cons(ok(X1),ok(X2)) = X1 >= X1 = ok(cons(X1,X2))
        
        incr(ok(X)) = X >= X = ok(incr(X))
        
        s(ok(X)) = 1 >= 1 = ok(s(X))
        
        take(ok(X1),ok(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = ok(take(X1,X2))
        
        zip(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(zip(X1,X2))
        
        pair(ok(X1),ok(X2)) = X1 + X2 >= X1 + X2 = ok(pair(X1,X2))
        
        tail(ok(X)) = X >= X = ok(tail(X))
        
        repItems(ok(X)) = X >= X = ok(repItems(X))
        
        top(mark(X)) = 0 >= 0 = top(proper(X))
        
        top(ok(X)) = 0 >= 0 = top(active(X))
       problem:
        DPs:
         active#(repItems(X)) -> active#(X)
         active#(tail(X)) -> active#(X)
         active#(pair(X1,X2)) -> active#(X2)
         active#(pair(X1,X2)) -> active#(X1)
         active#(zip(X1,X2)) -> active#(X2)
         active#(zip(X1,X2)) -> active#(X1)
         active#(incr(X)) -> active#(X)
        TRS:
         active(pairNs()) -> mark(cons(0(),incr(oddNs())))
         active(oddNs()) -> mark(incr(pairNs()))
         active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
         active(take(0(),XS)) -> mark(nil())
         active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
         active(zip(nil(),XS)) -> mark(nil())
         active(zip(X,nil())) -> mark(nil())
         active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
         active(tail(cons(X,XS))) -> mark(XS)
         active(repItems(nil())) -> mark(nil())
         active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
         active(cons(X1,X2)) -> cons(active(X1),X2)
         active(incr(X)) -> incr(active(X))
         active(s(X)) -> s(active(X))
         active(take(X1,X2)) -> take(active(X1),X2)
         active(take(X1,X2)) -> take(X1,active(X2))
         active(zip(X1,X2)) -> zip(active(X1),X2)
         active(zip(X1,X2)) -> zip(X1,active(X2))
         active(pair(X1,X2)) -> pair(active(X1),X2)
         active(pair(X1,X2)) -> pair(X1,active(X2))
         active(tail(X)) -> tail(active(X))
         active(repItems(X)) -> repItems(active(X))
         cons(mark(X1),X2) -> mark(cons(X1,X2))
         incr(mark(X)) -> mark(incr(X))
         s(mark(X)) -> mark(s(X))
         take(mark(X1),X2) -> mark(take(X1,X2))
         take(X1,mark(X2)) -> mark(take(X1,X2))
         zip(mark(X1),X2) -> mark(zip(X1,X2))
         zip(X1,mark(X2)) -> mark(zip(X1,X2))
         pair(mark(X1),X2) -> mark(pair(X1,X2))
         pair(X1,mark(X2)) -> mark(pair(X1,X2))
         tail(mark(X)) -> mark(tail(X))
         repItems(mark(X)) -> mark(repItems(X))
         proper(pairNs()) -> ok(pairNs())
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(0()) -> ok(0())
         proper(incr(X)) -> incr(proper(X))
         proper(oddNs()) -> ok(oddNs())
         proper(s(X)) -> s(proper(X))
         proper(take(X1,X2)) -> take(proper(X1),proper(X2))
         proper(nil()) -> ok(nil())
         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))
         cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
         incr(ok(X)) -> ok(incr(X))
         s(ok(X)) -> ok(s(X))
         take(ok(X1),ok(X2)) -> ok(take(X1,X2))
         zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
         pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
         tail(ok(X)) -> ok(tail(X))
         repItems(ok(X)) -> ok(repItems(X))
         top(mark(X)) -> top(proper(X))
         top(ok(X)) -> top(active(X))
       Matrix Interpretation Processor:
        dimension: 1
        interpretation:
         [active#](x0) = x0,
         
         [top](x0) = 1,
         
         [ok](x0) = 0,
         
         [proper](x0) = x0,
         
         [repItems](x0) = x0,
         
         [tail](x0) = x0,
         
         [pair](x0, x1) = x0 + x1,
         
         [zip](x0, x1) = x0 + x1,
         
         [nil] = 0,
         
         [take](x0, x1) = 0,
         
         [s](x0) = 0,
         
         [mark](x0) = 0,
         
         [cons](x0, x1) = 0,
         
         [incr](x0) = x0 + 1,
         
         [oddNs] = 0,
         
         [0] = 0,
         
         [active](x0) = x0,
         
         [pairNs] = 1
        orientation:
         active#(repItems(X)) = X >= X = active#(X)
         
         active#(tail(X)) = X >= X = active#(X)
         
         active#(pair(X1,X2)) = X1 + X2 >= X2 = active#(X2)
         
         active#(pair(X1,X2)) = X1 + X2 >= X1 = active#(X1)
         
         active#(zip(X1,X2)) = X1 + X2 >= X2 = active#(X2)
         
         active#(zip(X1,X2)) = X1 + X2 >= X1 = active#(X1)
         
         active#(incr(X)) = X + 1 >= X = active#(X)
         
         active(pairNs()) = 1 >= 0 = mark(cons(0(),incr(oddNs())))
         
         active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
         
         active(incr(cons(X,XS))) = 1 >= 0 = mark(cons(s(X),incr(XS)))
         
         active(take(0(),XS)) = 0 >= 0 = mark(nil())
         
         active(take(s(N),cons(X,XS))) = 0 >= 0 = mark(cons(X,take(N,XS)))
         
         active(zip(nil(),XS)) = XS >= 0 = mark(nil())
         
         active(zip(X,nil())) = X >= 0 = mark(nil())
         
         active(zip(cons(X,XS),cons(Y,YS))) = 0 >= 0 = mark(cons(pair(X,Y),zip(XS,YS)))
         
         active(tail(cons(X,XS))) = 0 >= 0 = mark(XS)
         
         active(repItems(nil())) = 0 >= 0 = mark(nil())
         
         active(repItems(cons(X,XS))) = 0 >= 0 = mark(cons(X,cons(X,repItems(XS))))
         
         active(cons(X1,X2)) = 0 >= 0 = cons(active(X1),X2)
         
         active(incr(X)) = X + 1 >= X + 1 = incr(active(X))
         
         active(s(X)) = 0 >= 0 = s(active(X))
         
         active(take(X1,X2)) = 0 >= 0 = take(active(X1),X2)
         
         active(take(X1,X2)) = 0 >= 0 = take(X1,active(X2))
         
         active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(active(X1),X2)
         
         active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(X1,active(X2))
         
         active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(active(X1),X2)
         
         active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(X1,active(X2))
         
         active(tail(X)) = X >= X = tail(active(X))
         
         active(repItems(X)) = X >= X = repItems(active(X))
         
         cons(mark(X1),X2) = 0 >= 0 = mark(cons(X1,X2))
         
         incr(mark(X)) = 1 >= 0 = mark(incr(X))
         
         s(mark(X)) = 0 >= 0 = mark(s(X))
         
         take(mark(X1),X2) = 0 >= 0 = mark(take(X1,X2))
         
         take(X1,mark(X2)) = 0 >= 0 = mark(take(X1,X2))
         
         zip(mark(X1),X2) = X2 >= 0 = mark(zip(X1,X2))
         
         zip(X1,mark(X2)) = X1 >= 0 = mark(zip(X1,X2))
         
         pair(mark(X1),X2) = X2 >= 0 = mark(pair(X1,X2))
         
         pair(X1,mark(X2)) = X1 >= 0 = mark(pair(X1,X2))
         
         tail(mark(X)) = 0 >= 0 = mark(tail(X))
         
         repItems(mark(X)) = 0 >= 0 = mark(repItems(X))
         
         proper(pairNs()) = 1 >= 0 = ok(pairNs())
         
         proper(cons(X1,X2)) = 0 >= 0 = cons(proper(X1),proper(X2))
         
         proper(0()) = 0 >= 0 = ok(0())
         
         proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
         
         proper(oddNs()) = 0 >= 0 = ok(oddNs())
         
         proper(s(X)) = 0 >= 0 = s(proper(X))
         
         proper(take(X1,X2)) = 0 >= 0 = take(proper(X1),proper(X2))
         
         proper(nil()) = 0 >= 0 = ok(nil())
         
         proper(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(proper(X1),proper(X2))
         
         proper(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(proper(X1),proper(X2))
         
         proper(tail(X)) = X >= X = tail(proper(X))
         
         proper(repItems(X)) = X >= X = repItems(proper(X))
         
         cons(ok(X1),ok(X2)) = 0 >= 0 = ok(cons(X1,X2))
         
         incr(ok(X)) = 1 >= 0 = ok(incr(X))
         
         s(ok(X)) = 0 >= 0 = ok(s(X))
         
         take(ok(X1),ok(X2)) = 0 >= 0 = ok(take(X1,X2))
         
         zip(ok(X1),ok(X2)) = 0 >= 0 = ok(zip(X1,X2))
         
         pair(ok(X1),ok(X2)) = 0 >= 0 = ok(pair(X1,X2))
         
         tail(ok(X)) = 0 >= 0 = ok(tail(X))
         
         repItems(ok(X)) = 0 >= 0 = ok(repItems(X))
         
         top(mark(X)) = 1 >= 1 = top(proper(X))
         
         top(ok(X)) = 1 >= 1 = top(active(X))
        problem:
         DPs:
          active#(repItems(X)) -> active#(X)
          active#(tail(X)) -> active#(X)
          active#(pair(X1,X2)) -> active#(X2)
          active#(pair(X1,X2)) -> active#(X1)
          active#(zip(X1,X2)) -> active#(X2)
          active#(zip(X1,X2)) -> active#(X1)
         TRS:
          active(pairNs()) -> mark(cons(0(),incr(oddNs())))
          active(oddNs()) -> mark(incr(pairNs()))
          active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
          active(take(0(),XS)) -> mark(nil())
          active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
          active(zip(nil(),XS)) -> mark(nil())
          active(zip(X,nil())) -> mark(nil())
          active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
          active(tail(cons(X,XS))) -> mark(XS)
          active(repItems(nil())) -> mark(nil())
          active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
          active(cons(X1,X2)) -> cons(active(X1),X2)
          active(incr(X)) -> incr(active(X))
          active(s(X)) -> s(active(X))
          active(take(X1,X2)) -> take(active(X1),X2)
          active(take(X1,X2)) -> take(X1,active(X2))
          active(zip(X1,X2)) -> zip(active(X1),X2)
          active(zip(X1,X2)) -> zip(X1,active(X2))
          active(pair(X1,X2)) -> pair(active(X1),X2)
          active(pair(X1,X2)) -> pair(X1,active(X2))
          active(tail(X)) -> tail(active(X))
          active(repItems(X)) -> repItems(active(X))
          cons(mark(X1),X2) -> mark(cons(X1,X2))
          incr(mark(X)) -> mark(incr(X))
          s(mark(X)) -> mark(s(X))
          take(mark(X1),X2) -> mark(take(X1,X2))
          take(X1,mark(X2)) -> mark(take(X1,X2))
          zip(mark(X1),X2) -> mark(zip(X1,X2))
          zip(X1,mark(X2)) -> mark(zip(X1,X2))
          pair(mark(X1),X2) -> mark(pair(X1,X2))
          pair(X1,mark(X2)) -> mark(pair(X1,X2))
          tail(mark(X)) -> mark(tail(X))
          repItems(mark(X)) -> mark(repItems(X))
          proper(pairNs()) -> ok(pairNs())
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(0()) -> ok(0())
          proper(incr(X)) -> incr(proper(X))
          proper(oddNs()) -> ok(oddNs())
          proper(s(X)) -> s(proper(X))
          proper(take(X1,X2)) -> take(proper(X1),proper(X2))
          proper(nil()) -> ok(nil())
          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))
          cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
          incr(ok(X)) -> ok(incr(X))
          s(ok(X)) -> ok(s(X))
          take(ok(X1),ok(X2)) -> ok(take(X1,X2))
          zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
          pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
          tail(ok(X)) -> ok(tail(X))
          repItems(ok(X)) -> ok(repItems(X))
          top(mark(X)) -> top(proper(X))
          top(ok(X)) -> top(active(X))
        Matrix Interpretation Processor:
         dimension: 1
         interpretation:
          [active#](x0) = x0 + 1,
          
          [top](x0) = 0,
          
          [ok](x0) = 0,
          
          [proper](x0) = x0,
          
          [repItems](x0) = x0 + 1,
          
          [tail](x0) = x0 + 1,
          
          [pair](x0, x1) = x0 + x1,
          
          [zip](x0, x1) = x0 + x1,
          
          [nil] = 0,
          
          [take](x0, x1) = 0,
          
          [s](x0) = 0,
          
          [mark](x0) = 0,
          
          [cons](x0, x1) = x1,
          
          [incr](x0) = 0,
          
          [oddNs] = 0,
          
          [0] = 0,
          
          [active](x0) = x0,
          
          [pairNs] = 0
         orientation:
          active#(repItems(X)) = X + 2 >= X + 1 = active#(X)
          
          active#(tail(X)) = X + 2 >= X + 1 = active#(X)
          
          active#(pair(X1,X2)) = X1 + X2 + 1 >= X2 + 1 = active#(X2)
          
          active#(pair(X1,X2)) = X1 + X2 + 1 >= X1 + 1 = active#(X1)
          
          active#(zip(X1,X2)) = X1 + X2 + 1 >= X2 + 1 = active#(X2)
          
          active#(zip(X1,X2)) = X1 + X2 + 1 >= X1 + 1 = active#(X1)
          
          active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
          
          active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
          
          active(incr(cons(X,XS))) = 0 >= 0 = mark(cons(s(X),incr(XS)))
          
          active(take(0(),XS)) = 0 >= 0 = mark(nil())
          
          active(take(s(N),cons(X,XS))) = 0 >= 0 = mark(cons(X,take(N,XS)))
          
          active(zip(nil(),XS)) = XS >= 0 = mark(nil())
          
          active(zip(X,nil())) = X >= 0 = mark(nil())
          
          active(zip(cons(X,XS),cons(Y,YS))) = XS + YS >= 0 = mark(cons(pair(X,Y),zip(XS,YS)))
          
          active(tail(cons(X,XS))) = XS + 1 >= 0 = mark(XS)
          
          active(repItems(nil())) = 1 >= 0 = mark(nil())
          
          active(repItems(cons(X,XS))) = XS + 1 >= 0 = mark(cons(X,cons(X,repItems(XS))))
          
          active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
          
          active(incr(X)) = 0 >= 0 = incr(active(X))
          
          active(s(X)) = 0 >= 0 = s(active(X))
          
          active(take(X1,X2)) = 0 >= 0 = take(active(X1),X2)
          
          active(take(X1,X2)) = 0 >= 0 = take(X1,active(X2))
          
          active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(active(X1),X2)
          
          active(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(X1,active(X2))
          
          active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(active(X1),X2)
          
          active(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(X1,active(X2))
          
          active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
          
          active(repItems(X)) = X + 1 >= X + 1 = repItems(active(X))
          
          cons(mark(X1),X2) = X2 >= 0 = mark(cons(X1,X2))
          
          incr(mark(X)) = 0 >= 0 = mark(incr(X))
          
          s(mark(X)) = 0 >= 0 = mark(s(X))
          
          take(mark(X1),X2) = 0 >= 0 = mark(take(X1,X2))
          
          take(X1,mark(X2)) = 0 >= 0 = mark(take(X1,X2))
          
          zip(mark(X1),X2) = X2 >= 0 = mark(zip(X1,X2))
          
          zip(X1,mark(X2)) = X1 >= 0 = mark(zip(X1,X2))
          
          pair(mark(X1),X2) = X2 >= 0 = mark(pair(X1,X2))
          
          pair(X1,mark(X2)) = X1 >= 0 = mark(pair(X1,X2))
          
          tail(mark(X)) = 1 >= 0 = mark(tail(X))
          
          repItems(mark(X)) = 1 >= 0 = mark(repItems(X))
          
          proper(pairNs()) = 0 >= 0 = ok(pairNs())
          
          proper(cons(X1,X2)) = X2 >= X2 = cons(proper(X1),proper(X2))
          
          proper(0()) = 0 >= 0 = ok(0())
          
          proper(incr(X)) = 0 >= 0 = incr(proper(X))
          
          proper(oddNs()) = 0 >= 0 = ok(oddNs())
          
          proper(s(X)) = 0 >= 0 = s(proper(X))
          
          proper(take(X1,X2)) = 0 >= 0 = take(proper(X1),proper(X2))
          
          proper(nil()) = 0 >= 0 = ok(nil())
          
          proper(zip(X1,X2)) = X1 + X2 >= X1 + X2 = zip(proper(X1),proper(X2))
          
          proper(pair(X1,X2)) = X1 + X2 >= X1 + X2 = pair(proper(X1),proper(X2))
          
          proper(tail(X)) = X + 1 >= X + 1 = tail(proper(X))
          
          proper(repItems(X)) = X + 1 >= X + 1 = repItems(proper(X))
          
          cons(ok(X1),ok(X2)) = 0 >= 0 = ok(cons(X1,X2))
          
          incr(ok(X)) = 0 >= 0 = ok(incr(X))
          
          s(ok(X)) = 0 >= 0 = ok(s(X))
          
          take(ok(X1),ok(X2)) = 0 >= 0 = ok(take(X1,X2))
          
          zip(ok(X1),ok(X2)) = 0 >= 0 = ok(zip(X1,X2))
          
          pair(ok(X1),ok(X2)) = 0 >= 0 = ok(pair(X1,X2))
          
          tail(ok(X)) = 1 >= 0 = ok(tail(X))
          
          repItems(ok(X)) = 1 >= 0 = ok(repItems(X))
          
          top(mark(X)) = 0 >= 0 = top(proper(X))
          
          top(ok(X)) = 0 >= 0 = top(active(X))
         problem:
          DPs:
           active#(pair(X1,X2)) -> active#(X2)
           active#(pair(X1,X2)) -> active#(X1)
           active#(zip(X1,X2)) -> active#(X2)
           active#(zip(X1,X2)) -> active#(X1)
          TRS:
           active(pairNs()) -> mark(cons(0(),incr(oddNs())))
           active(oddNs()) -> mark(incr(pairNs()))
           active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
           active(take(0(),XS)) -> mark(nil())
           active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
           active(zip(nil(),XS)) -> mark(nil())
           active(zip(X,nil())) -> mark(nil())
           active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
           active(tail(cons(X,XS))) -> mark(XS)
           active(repItems(nil())) -> mark(nil())
           active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
           active(cons(X1,X2)) -> cons(active(X1),X2)
           active(incr(X)) -> incr(active(X))
           active(s(X)) -> s(active(X))
           active(take(X1,X2)) -> take(active(X1),X2)
           active(take(X1,X2)) -> take(X1,active(X2))
           active(zip(X1,X2)) -> zip(active(X1),X2)
           active(zip(X1,X2)) -> zip(X1,active(X2))
           active(pair(X1,X2)) -> pair(active(X1),X2)
           active(pair(X1,X2)) -> pair(X1,active(X2))
           active(tail(X)) -> tail(active(X))
           active(repItems(X)) -> repItems(active(X))
           cons(mark(X1),X2) -> mark(cons(X1,X2))
           incr(mark(X)) -> mark(incr(X))
           s(mark(X)) -> mark(s(X))
           take(mark(X1),X2) -> mark(take(X1,X2))
           take(X1,mark(X2)) -> mark(take(X1,X2))
           zip(mark(X1),X2) -> mark(zip(X1,X2))
           zip(X1,mark(X2)) -> mark(zip(X1,X2))
           pair(mark(X1),X2) -> mark(pair(X1,X2))
           pair(X1,mark(X2)) -> mark(pair(X1,X2))
           tail(mark(X)) -> mark(tail(X))
           repItems(mark(X)) -> mark(repItems(X))
           proper(pairNs()) -> ok(pairNs())
           proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
           proper(0()) -> ok(0())
           proper(incr(X)) -> incr(proper(X))
           proper(oddNs()) -> ok(oddNs())
           proper(s(X)) -> s(proper(X))
           proper(take(X1,X2)) -> take(proper(X1),proper(X2))
           proper(nil()) -> ok(nil())
           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))
           cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
           incr(ok(X)) -> ok(incr(X))
           s(ok(X)) -> ok(s(X))
           take(ok(X1),ok(X2)) -> ok(take(X1,X2))
           zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
           pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
           tail(ok(X)) -> ok(tail(X))
           repItems(ok(X)) -> ok(repItems(X))
           top(mark(X)) -> top(proper(X))
           top(ok(X)) -> top(active(X))
         Matrix Interpretation Processor:
          dimension: 1
          interpretation:
           [active#](x0) = x0 + 1,
           
           [top](x0) = 0,
           
           [ok](x0) = 0,
           
           [proper](x0) = x0,
           
           [repItems](x0) = 1,
           
           [tail](x0) = x0 + 1,
           
           [pair](x0, x1) = x0 + x1 + 1,
           
           [zip](x0, x1) = x0 + x1 + 1,
           
           [nil] = 0,
           
           [take](x0, x1) = 1,
           
           [s](x0) = 1,
           
           [mark](x0) = 1,
           
           [cons](x0, x1) = x0 + x1,
           
           [incr](x0) = 1,
           
           [oddNs] = 1,
           
           [0] = 0,
           
           [active](x0) = x0,
           
           [pairNs] = 1
          orientation:
           active#(pair(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = active#(X2)
           
           active#(pair(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = active#(X1)
           
           active#(zip(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = active#(X2)
           
           active#(zip(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = active#(X1)
           
           active(pairNs()) = 1 >= 1 = mark(cons(0(),incr(oddNs())))
           
           active(oddNs()) = 1 >= 1 = mark(incr(pairNs()))
           
           active(incr(cons(X,XS))) = 1 >= 1 = mark(cons(s(X),incr(XS)))
           
           active(take(0(),XS)) = 1 >= 1 = mark(nil())
           
           active(take(s(N),cons(X,XS))) = 1 >= 1 = mark(cons(X,take(N,XS)))
           
           active(zip(nil(),XS)) = XS + 1 >= 1 = mark(nil())
           
           active(zip(X,nil())) = X + 1 >= 1 = mark(nil())
           
           active(zip(cons(X,XS),cons(Y,YS))) = X + XS + Y + YS + 1 >= 1 = mark(cons(pair(X,Y),zip(XS,YS)))
           
           active(tail(cons(X,XS))) = X + XS + 1 >= 1 = mark(XS)
           
           active(repItems(nil())) = 1 >= 1 = mark(nil())
           
           active(repItems(cons(X,XS))) = 1 >= 1 = mark(cons(X,cons(X,repItems(XS))))
           
           active(cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(active(X1),X2)
           
           active(incr(X)) = 1 >= 1 = incr(active(X))
           
           active(s(X)) = 1 >= 1 = s(active(X))
           
           active(take(X1,X2)) = 1 >= 1 = take(active(X1),X2)
           
           active(take(X1,X2)) = 1 >= 1 = take(X1,active(X2))
           
           active(zip(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = zip(active(X1),X2)
           
           active(zip(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = zip(X1,active(X2))
           
           active(pair(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = pair(active(X1),X2)
           
           active(pair(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = pair(X1,active(X2))
           
           active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
           
           active(repItems(X)) = 1 >= 1 = repItems(active(X))
           
           cons(mark(X1),X2) = X2 + 1 >= 1 = mark(cons(X1,X2))
           
           incr(mark(X)) = 1 >= 1 = mark(incr(X))
           
           s(mark(X)) = 1 >= 1 = mark(s(X))
           
           take(mark(X1),X2) = 1 >= 1 = mark(take(X1,X2))
           
           take(X1,mark(X2)) = 1 >= 1 = mark(take(X1,X2))
           
           zip(mark(X1),X2) = X2 + 2 >= 1 = mark(zip(X1,X2))
           
           zip(X1,mark(X2)) = X1 + 2 >= 1 = mark(zip(X1,X2))
           
           pair(mark(X1),X2) = X2 + 2 >= 1 = mark(pair(X1,X2))
           
           pair(X1,mark(X2)) = X1 + 2 >= 1 = mark(pair(X1,X2))
           
           tail(mark(X)) = 2 >= 1 = mark(tail(X))
           
           repItems(mark(X)) = 1 >= 1 = mark(repItems(X))
           
           proper(pairNs()) = 1 >= 0 = ok(pairNs())
           
           proper(cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(proper(X1),proper(X2))
           
           proper(0()) = 0 >= 0 = ok(0())
           
           proper(incr(X)) = 1 >= 1 = incr(proper(X))
           
           proper(oddNs()) = 1 >= 0 = ok(oddNs())
           
           proper(s(X)) = 1 >= 1 = s(proper(X))
           
           proper(take(X1,X2)) = 1 >= 1 = take(proper(X1),proper(X2))
           
           proper(nil()) = 0 >= 0 = ok(nil())
           
           proper(zip(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = zip(proper(X1),proper(X2))
           
           proper(pair(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = pair(proper(X1),proper(X2))
           
           proper(tail(X)) = X + 1 >= X + 1 = tail(proper(X))
           
           proper(repItems(X)) = 1 >= 1 = repItems(proper(X))
           
           cons(ok(X1),ok(X2)) = 0 >= 0 = ok(cons(X1,X2))
           
           incr(ok(X)) = 1 >= 0 = ok(incr(X))
           
           s(ok(X)) = 1 >= 0 = ok(s(X))
           
           take(ok(X1),ok(X2)) = 1 >= 0 = ok(take(X1,X2))
           
           zip(ok(X1),ok(X2)) = 1 >= 0 = ok(zip(X1,X2))
           
           pair(ok(X1),ok(X2)) = 1 >= 0 = ok(pair(X1,X2))
           
           tail(ok(X)) = 1 >= 0 = ok(tail(X))
           
           repItems(ok(X)) = 1 >= 0 = ok(repItems(X))
           
           top(mark(X)) = 0 >= 0 = top(proper(X))
           
           top(ok(X)) = 0 >= 0 = top(active(X))
          problem:
           DPs:
            
           TRS:
            active(pairNs()) -> mark(cons(0(),incr(oddNs())))
            active(oddNs()) -> mark(incr(pairNs()))
            active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
            active(take(0(),XS)) -> mark(nil())
            active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
            active(zip(nil(),XS)) -> mark(nil())
            active(zip(X,nil())) -> mark(nil())
            active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
            active(tail(cons(X,XS))) -> mark(XS)
            active(repItems(nil())) -> mark(nil())
            active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
            active(cons(X1,X2)) -> cons(active(X1),X2)
            active(incr(X)) -> incr(active(X))
            active(s(X)) -> s(active(X))
            active(take(X1,X2)) -> take(active(X1),X2)
            active(take(X1,X2)) -> take(X1,active(X2))
            active(zip(X1,X2)) -> zip(active(X1),X2)
            active(zip(X1,X2)) -> zip(X1,active(X2))
            active(pair(X1,X2)) -> pair(active(X1),X2)
            active(pair(X1,X2)) -> pair(X1,active(X2))
            active(tail(X)) -> tail(active(X))
            active(repItems(X)) -> repItems(active(X))
            cons(mark(X1),X2) -> mark(cons(X1,X2))
            incr(mark(X)) -> mark(incr(X))
            s(mark(X)) -> mark(s(X))
            take(mark(X1),X2) -> mark(take(X1,X2))
            take(X1,mark(X2)) -> mark(take(X1,X2))
            zip(mark(X1),X2) -> mark(zip(X1,X2))
            zip(X1,mark(X2)) -> mark(zip(X1,X2))
            pair(mark(X1),X2) -> mark(pair(X1,X2))
            pair(X1,mark(X2)) -> mark(pair(X1,X2))
            tail(mark(X)) -> mark(tail(X))
            repItems(mark(X)) -> mark(repItems(X))
            proper(pairNs()) -> ok(pairNs())
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(0()) -> ok(0())
            proper(incr(X)) -> incr(proper(X))
            proper(oddNs()) -> ok(oddNs())
            proper(s(X)) -> s(proper(X))
            proper(take(X1,X2)) -> take(proper(X1),proper(X2))
            proper(nil()) -> ok(nil())
            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))
            cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
            incr(ok(X)) -> ok(incr(X))
            s(ok(X)) -> ok(s(X))
            take(ok(X1),ok(X2)) -> ok(take(X1,X2))
            zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
            pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
            tail(ok(X)) -> ok(tail(X))
            repItems(ok(X)) -> ok(repItems(X))
            top(mark(X)) -> top(proper(X))
            top(ok(X)) -> top(active(X))
          Qed
    
    DPs:
     cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [cons#](x0, x1) = x1 + 1,
      
      [top](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = 1,
      
      [repItems](x0) = x0,
      
      [tail](x0) = x0,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x1,
      
      [s](x0) = x0,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 0,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      cons#(ok(X1),ok(X2)) = X2 + 2 >= X2 + 1 = cons#(X1,X2)
      
      cons#(mark(X1),X2) = X2 + 1 >= X2 + 1 = cons#(X1,X2)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = XS >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = XS >= XS = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS >= XS = mark(XS)
      
      active(repItems(nil())) = 0 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS >= XS = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X2 >= X2 = take(active(X1),X2)
      
      active(take(X1,X2)) = X2 >= X2 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X >= X = tail(active(X))
      
      active(repItems(X)) = X >= X = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X >= X = mark(s(X))
      
      take(mark(X1),X2) = X2 >= X2 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X2 >= X2 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X >= X = mark(tail(X))
      
      repItems(mark(X)) = X >= X = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = 1 >= 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 1 >= 1 = ok(0())
      
      proper(incr(X)) = 1 >= 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = 1 >= 1 = s(proper(X))
      
      proper(take(X1,X2)) = 1 >= 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = 1 >= 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = 1 >= 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = 1 >= 1 = tail(proper(X))
      
      proper(repItems(X)) = 1 >= 1 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 1 >= X + 1 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 1 >= X + 1 = ok(tail(X))
      
      repItems(ok(X)) = X + 1 >= X + 1 = ok(repItems(X))
      
      top(mark(X)) = 0 >= 0 = top(proper(X))
      
      top(ok(X)) = 0 >= 0 = top(active(X))
     problem:
      DPs:
       cons#(mark(X1),X2) -> cons#(X1,X2)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     incr#(ok(X)) -> incr#(X)
     incr#(mark(X)) -> incr#(X)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [incr#](x0) = x0,
      
      [top](x0) = 1,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 1,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      incr#(ok(X)) = X + 1 >= X = incr#(X)
      
      incr#(mark(X)) = X >= X = incr#(X)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 1 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 0 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS >= XS = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X >= X = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X >= X = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X >= X = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 2 >= 2 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 1 >= X + 1 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 1 >= X + 1 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 1 >= X + 1 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 1 >= X + 1 = ok(repItems(X))
      
      top(mark(X)) = 1 >= 1 = top(proper(X))
      
      top(ok(X)) = 1 >= 1 = top(active(X))
     problem:
      DPs:
       incr#(mark(X)) -> incr#(X)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     s#(ok(X)) -> s#(X)
     s#(mark(X)) -> s#(X)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [s#](x0) = x0,
      
      [top](x0) = 1,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 1,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      s#(ok(X)) = X + 1 >= X = s#(X)
      
      s#(mark(X)) = X >= X = s#(X)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 1 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 0 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS >= XS = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X >= X = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X >= X = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X >= X = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 2 >= 2 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 1 >= X + 1 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 1 >= X + 1 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 1 >= X + 1 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 1 >= X + 1 = ok(repItems(X))
      
      top(mark(X)) = 1 >= 1 = top(proper(X))
      
      top(ok(X)) = 1 >= 1 = top(active(X))
     problem:
      DPs:
       s#(mark(X)) -> s#(X)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     take#(ok(X1),ok(X2)) -> take#(X1,X2)
     take#(X1,mark(X2)) -> take#(X1,X2)
     take#(mark(X1),X2) -> take#(X1,X2)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [take#](x0, x1) = x1,
      
      [top](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0 + 1,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0 + 1,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 0,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      take#(ok(X1),ok(X2)) = X2 + 1 >= X2 = take#(X1,X2)
      
      take#(X1,mark(X2)) = X2 >= X2 = take#(X1,X2)
      
      take#(mark(X1),X2) = X2 >= X2 = take#(X1,X2)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 0 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N + 1 >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 1 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS + 1 >= XS + 1 = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X + 1 >= X + 1 = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X + 1 >= X + 1 = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X + 1 >= X + 1 = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X + 1 >= X + 1 = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 1 >= 1 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 2 >= X + 2 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 2 >= X + 2 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 2 >= X + 2 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 2 >= X + 2 = ok(repItems(X))
      
      top(mark(X)) = 0 >= 0 = top(proper(X))
      
      top(ok(X)) = 0 >= 0 = top(active(X))
     problem:
      DPs:
       take#(X1,mark(X2)) -> take#(X1,X2)
       take#(mark(X1),X2) -> take#(X1,X2)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     zip#(ok(X1),ok(X2)) -> zip#(X1,X2)
     zip#(X1,mark(X2)) -> zip#(X1,X2)
     zip#(mark(X1),X2) -> zip#(X1,X2)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [zip#](x0, x1) = x1,
      
      [top](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0 + 1,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0 + 1,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 0,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      zip#(ok(X1),ok(X2)) = X2 + 1 >= X2 = zip#(X1,X2)
      
      zip#(X1,mark(X2)) = X2 >= X2 = zip#(X1,X2)
      
      zip#(mark(X1),X2) = X2 >= X2 = zip#(X1,X2)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 0 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N + 1 >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 1 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS + 1 >= XS + 1 = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X + 1 >= X + 1 = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X + 1 >= X + 1 = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X + 1 >= X + 1 = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X + 1 >= X + 1 = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 1 >= 1 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 2 >= X + 2 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 2 >= X + 2 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 2 >= X + 2 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 2 >= X + 2 = ok(repItems(X))
      
      top(mark(X)) = 0 >= 0 = top(proper(X))
      
      top(ok(X)) = 0 >= 0 = top(active(X))
     problem:
      DPs:
       zip#(X1,mark(X2)) -> zip#(X1,X2)
       zip#(mark(X1),X2) -> zip#(X1,X2)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     pair#(ok(X1),ok(X2)) -> pair#(X1,X2)
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     pair#(mark(X1),X2) -> pair#(X1,X2)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [pair#](x0, x1) = x1,
      
      [top](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0 + 1,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0 + 1,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 0,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      pair#(ok(X1),ok(X2)) = X2 + 1 >= X2 = pair#(X1,X2)
      
      pair#(X1,mark(X2)) = X2 >= X2 = pair#(X1,X2)
      
      pair#(mark(X1),X2) = X2 >= X2 = pair#(X1,X2)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 0 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N + 1 >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 1 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS + 1 >= XS + 1 = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X + 1 >= X + 1 = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X + 1 >= X + 1 = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X + 1 >= X + 1 = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X + 1 >= X + 1 = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 1 >= 1 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 2 >= X + 2 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 2 >= X + 2 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 2 >= X + 2 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 2 >= X + 2 = ok(repItems(X))
      
      top(mark(X)) = 0 >= 0 = top(proper(X))
      
      top(ok(X)) = 0 >= 0 = top(active(X))
     problem:
      DPs:
       pair#(X1,mark(X2)) -> pair#(X1,X2)
       pair#(mark(X1),X2) -> pair#(X1,X2)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     tail#(ok(X)) -> tail#(X)
     tail#(mark(X)) -> tail#(X)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [tail#](x0) = x0,
      
      [top](x0) = 1,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 1,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      tail#(ok(X)) = X + 1 >= X = tail#(X)
      
      tail#(mark(X)) = X >= X = tail#(X)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 1 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 0 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS >= XS = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X >= X = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X >= X = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X >= X = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 2 >= 2 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 1 >= X + 1 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 1 >= X + 1 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 1 >= X + 1 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 1 >= X + 1 = ok(repItems(X))
      
      top(mark(X)) = 1 >= 1 = top(proper(X))
      
      top(ok(X)) = 1 >= 1 = top(active(X))
     problem:
      DPs:
       tail#(mark(X)) -> tail#(X)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open
    
    DPs:
     repItems#(ok(X)) -> repItems#(X)
     repItems#(mark(X)) -> repItems#(X)
    TRS:
     active(pairNs()) -> mark(cons(0(),incr(oddNs())))
     active(oddNs()) -> mark(incr(pairNs()))
     active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
     active(take(0(),XS)) -> mark(nil())
     active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
     active(zip(nil(),XS)) -> mark(nil())
     active(zip(X,nil())) -> mark(nil())
     active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
     active(tail(cons(X,XS))) -> mark(XS)
     active(repItems(nil())) -> mark(nil())
     active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(incr(X)) -> incr(active(X))
     active(s(X)) -> s(active(X))
     active(take(X1,X2)) -> take(active(X1),X2)
     active(take(X1,X2)) -> take(X1,active(X2))
     active(zip(X1,X2)) -> zip(active(X1),X2)
     active(zip(X1,X2)) -> zip(X1,active(X2))
     active(pair(X1,X2)) -> pair(active(X1),X2)
     active(pair(X1,X2)) -> pair(X1,active(X2))
     active(tail(X)) -> tail(active(X))
     active(repItems(X)) -> repItems(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     incr(mark(X)) -> mark(incr(X))
     s(mark(X)) -> mark(s(X))
     take(mark(X1),X2) -> mark(take(X1,X2))
     take(X1,mark(X2)) -> mark(take(X1,X2))
     zip(mark(X1),X2) -> mark(zip(X1,X2))
     zip(X1,mark(X2)) -> mark(zip(X1,X2))
     pair(mark(X1),X2) -> mark(pair(X1,X2))
     pair(X1,mark(X2)) -> mark(pair(X1,X2))
     tail(mark(X)) -> mark(tail(X))
     repItems(mark(X)) -> mark(repItems(X))
     proper(pairNs()) -> ok(pairNs())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(incr(X)) -> incr(proper(X))
     proper(oddNs()) -> ok(oddNs())
     proper(s(X)) -> s(proper(X))
     proper(take(X1,X2)) -> take(proper(X1),proper(X2))
     proper(nil()) -> ok(nil())
     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))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     incr(ok(X)) -> ok(incr(X))
     s(ok(X)) -> ok(s(X))
     take(ok(X1),ok(X2)) -> ok(take(X1,X2))
     zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
     pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     repItems(ok(X)) -> ok(repItems(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    Matrix Interpretation Processor:
     dimension: 1
     interpretation:
      [repItems#](x0) = x0,
      
      [top](x0) = 1,
      
      [ok](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [repItems](x0) = x0,
      
      [tail](x0) = x0 + 1,
      
      [pair](x0, x1) = x1,
      
      [zip](x0, x1) = x1,
      
      [nil] = 0,
      
      [take](x0, x1) = x0,
      
      [s](x0) = x0,
      
      [mark](x0) = x0,
      
      [cons](x0, x1) = x1,
      
      [incr](x0) = x0,
      
      [oddNs] = 0,
      
      [0] = 1,
      
      [active](x0) = x0,
      
      [pairNs] = 0
     orientation:
      repItems#(ok(X)) = X + 1 >= X = repItems#(X)
      
      repItems#(mark(X)) = X >= X = repItems#(X)
      
      active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs())))
      
      active(oddNs()) = 0 >= 0 = mark(incr(pairNs()))
      
      active(incr(cons(X,XS))) = XS >= XS = mark(cons(s(X),incr(XS)))
      
      active(take(0(),XS)) = 1 >= 0 = mark(nil())
      
      active(take(s(N),cons(X,XS))) = N >= N = mark(cons(X,take(N,XS)))
      
      active(zip(nil(),XS)) = XS >= 0 = mark(nil())
      
      active(zip(X,nil())) = 0 >= 0 = mark(nil())
      
      active(zip(cons(X,XS),cons(Y,YS))) = YS >= YS = mark(cons(pair(X,Y),zip(XS,YS)))
      
      active(tail(cons(X,XS))) = XS + 1 >= XS = mark(XS)
      
      active(repItems(nil())) = 0 >= 0 = mark(nil())
      
      active(repItems(cons(X,XS))) = XS >= XS = mark(cons(X,cons(X,repItems(XS))))
      
      active(cons(X1,X2)) = X2 >= X2 = cons(active(X1),X2)
      
      active(incr(X)) = X >= X = incr(active(X))
      
      active(s(X)) = X >= X = s(active(X))
      
      active(take(X1,X2)) = X1 >= X1 = take(active(X1),X2)
      
      active(take(X1,X2)) = X1 >= X1 = take(X1,active(X2))
      
      active(zip(X1,X2)) = X2 >= X2 = zip(active(X1),X2)
      
      active(zip(X1,X2)) = X2 >= X2 = zip(X1,active(X2))
      
      active(pair(X1,X2)) = X2 >= X2 = pair(active(X1),X2)
      
      active(pair(X1,X2)) = X2 >= X2 = pair(X1,active(X2))
      
      active(tail(X)) = X + 1 >= X + 1 = tail(active(X))
      
      active(repItems(X)) = X >= X = repItems(active(X))
      
      cons(mark(X1),X2) = X2 >= X2 = mark(cons(X1,X2))
      
      incr(mark(X)) = X >= X = mark(incr(X))
      
      s(mark(X)) = X >= X = mark(s(X))
      
      take(mark(X1),X2) = X1 >= X1 = mark(take(X1,X2))
      
      take(X1,mark(X2)) = X1 >= X1 = mark(take(X1,X2))
      
      zip(mark(X1),X2) = X2 >= X2 = mark(zip(X1,X2))
      
      zip(X1,mark(X2)) = X2 >= X2 = mark(zip(X1,X2))
      
      pair(mark(X1),X2) = X2 >= X2 = mark(pair(X1,X2))
      
      pair(X1,mark(X2)) = X2 >= X2 = mark(pair(X1,X2))
      
      tail(mark(X)) = X + 1 >= X + 1 = mark(tail(X))
      
      repItems(mark(X)) = X >= X = mark(repItems(X))
      
      proper(pairNs()) = 1 >= 1 = ok(pairNs())
      
      proper(cons(X1,X2)) = X2 + 1 >= X2 + 1 = cons(proper(X1),proper(X2))
      
      proper(0()) = 2 >= 2 = ok(0())
      
      proper(incr(X)) = X + 1 >= X + 1 = incr(proper(X))
      
      proper(oddNs()) = 1 >= 1 = ok(oddNs())
      
      proper(s(X)) = X + 1 >= X + 1 = s(proper(X))
      
      proper(take(X1,X2)) = X1 + 1 >= X1 + 1 = take(proper(X1),proper(X2))
      
      proper(nil()) = 1 >= 1 = ok(nil())
      
      proper(zip(X1,X2)) = X2 + 1 >= X2 + 1 = zip(proper(X1),proper(X2))
      
      proper(pair(X1,X2)) = X2 + 1 >= X2 + 1 = pair(proper(X1),proper(X2))
      
      proper(tail(X)) = X + 2 >= X + 2 = tail(proper(X))
      
      proper(repItems(X)) = X + 1 >= X + 1 = repItems(proper(X))
      
      cons(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(cons(X1,X2))
      
      incr(ok(X)) = X + 1 >= X + 1 = ok(incr(X))
      
      s(ok(X)) = X + 1 >= X + 1 = ok(s(X))
      
      take(ok(X1),ok(X2)) = X1 + 1 >= X1 + 1 = ok(take(X1,X2))
      
      zip(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(zip(X1,X2))
      
      pair(ok(X1),ok(X2)) = X2 + 1 >= X2 + 1 = ok(pair(X1,X2))
      
      tail(ok(X)) = X + 2 >= X + 2 = ok(tail(X))
      
      repItems(ok(X)) = X + 1 >= X + 1 = ok(repItems(X))
      
      top(mark(X)) = 1 >= 1 = top(proper(X))
      
      top(ok(X)) = 1 >= 1 = top(active(X))
     problem:
      DPs:
       repItems#(mark(X)) -> repItems#(X)
      TRS:
       active(pairNs()) -> mark(cons(0(),incr(oddNs())))
       active(oddNs()) -> mark(incr(pairNs()))
       active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
       active(take(0(),XS)) -> mark(nil())
       active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
       active(zip(nil(),XS)) -> mark(nil())
       active(zip(X,nil())) -> mark(nil())
       active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
       active(tail(cons(X,XS))) -> mark(XS)
       active(repItems(nil())) -> mark(nil())
       active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(incr(X)) -> incr(active(X))
       active(s(X)) -> s(active(X))
       active(take(X1,X2)) -> take(active(X1),X2)
       active(take(X1,X2)) -> take(X1,active(X2))
       active(zip(X1,X2)) -> zip(active(X1),X2)
       active(zip(X1,X2)) -> zip(X1,active(X2))
       active(pair(X1,X2)) -> pair(active(X1),X2)
       active(pair(X1,X2)) -> pair(X1,active(X2))
       active(tail(X)) -> tail(active(X))
       active(repItems(X)) -> repItems(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       incr(mark(X)) -> mark(incr(X))
       s(mark(X)) -> mark(s(X))
       take(mark(X1),X2) -> mark(take(X1,X2))
       take(X1,mark(X2)) -> mark(take(X1,X2))
       zip(mark(X1),X2) -> mark(zip(X1,X2))
       zip(X1,mark(X2)) -> mark(zip(X1,X2))
       pair(mark(X1),X2) -> mark(pair(X1,X2))
       pair(X1,mark(X2)) -> mark(pair(X1,X2))
       tail(mark(X)) -> mark(tail(X))
       repItems(mark(X)) -> mark(repItems(X))
       proper(pairNs()) -> ok(pairNs())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(incr(X)) -> incr(proper(X))
       proper(oddNs()) -> ok(oddNs())
       proper(s(X)) -> s(proper(X))
       proper(take(X1,X2)) -> take(proper(X1),proper(X2))
       proper(nil()) -> ok(nil())
       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))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       incr(ok(X)) -> ok(incr(X))
       s(ok(X)) -> ok(s(X))
       take(ok(X1),ok(X2)) -> ok(take(X1,X2))
       zip(ok(X1),ok(X2)) -> ok(zip(X1,X2))
       pair(ok(X1),ok(X2)) -> ok(pair(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       repItems(ok(X)) -> ok(repItems(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
     Open