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))))
 mark(pairNs()) -> active(pairNs())
 mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
 mark(0()) -> active(0())
 mark(incr(X)) -> active(incr(mark(X)))
 mark(oddNs()) -> active(oddNs())
 mark(s(X)) -> active(s(mark(X)))
 mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
 mark(nil()) -> active(nil())
 mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
 mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
 mark(tail(X)) -> active(tail(mark(X)))
 mark(repItems(X)) -> active(repItems(mark(X)))
 cons(mark(X1),X2) -> cons(X1,X2)
 cons(X1,mark(X2)) -> cons(X1,X2)
 cons(active(X1),X2) -> cons(X1,X2)
 cons(X1,active(X2)) -> cons(X1,X2)
 incr(mark(X)) -> incr(X)
 incr(active(X)) -> incr(X)
 s(mark(X)) -> s(X)
 s(active(X)) -> s(X)
 take(mark(X1),X2) -> take(X1,X2)
 take(X1,mark(X2)) -> take(X1,X2)
 take(active(X1),X2) -> take(X1,X2)
 take(X1,active(X2)) -> take(X1,X2)
 zip(mark(X1),X2) -> zip(X1,X2)
 zip(X1,mark(X2)) -> zip(X1,X2)
 zip(active(X1),X2) -> zip(X1,X2)
 zip(X1,active(X2)) -> zip(X1,X2)
 pair(mark(X1),X2) -> pair(X1,X2)
 pair(X1,mark(X2)) -> pair(X1,X2)
 pair(active(X1),X2) -> pair(X1,X2)
 pair(X1,active(X2)) -> pair(X1,X2)
 tail(mark(X)) -> tail(X)
 tail(active(X)) -> tail(X)
 repItems(mark(X)) -> repItems(X)
 repItems(active(X)) -> repItems(X)

Proof:
 DP Processor:
  DPs:
   active#(pairNs()) -> incr#(oddNs())
   active#(pairNs()) -> cons#(0(),incr(oddNs()))
   active#(pairNs()) -> mark#(cons(0(),incr(oddNs())))
   active#(oddNs()) -> incr#(pairNs())
   active#(oddNs()) -> mark#(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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
   active#(take(0(),XS)) -> mark#(nil())
   active#(take(s(N),cons(X,XS))) -> take#(N,XS)
   active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
   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))) -> 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#(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))) -> repItems#(XS)
   active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
   active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
   active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
   mark#(pairNs()) -> active#(pairNs())
   mark#(cons(X1,X2)) -> mark#(X1)
   mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
   mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
   mark#(0()) -> active#(0())
   mark#(incr(X)) -> mark#(X)
   mark#(incr(X)) -> incr#(mark(X))
   mark#(incr(X)) -> active#(incr(mark(X)))
   mark#(oddNs()) -> active#(oddNs())
   mark#(s(X)) -> mark#(X)
   mark#(s(X)) -> s#(mark(X))
   mark#(s(X)) -> active#(s(mark(X)))
   mark#(take(X1,X2)) -> mark#(X2)
   mark#(take(X1,X2)) -> mark#(X1)
   mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
   mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
   mark#(nil()) -> active#(nil())
   mark#(zip(X1,X2)) -> mark#(X2)
   mark#(zip(X1,X2)) -> mark#(X1)
   mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
   mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
   mark#(pair(X1,X2)) -> mark#(X2)
   mark#(pair(X1,X2)) -> mark#(X1)
   mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
   mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
   mark#(tail(X)) -> mark#(X)
   mark#(tail(X)) -> tail#(mark(X))
   mark#(tail(X)) -> active#(tail(mark(X)))
   mark#(repItems(X)) -> mark#(X)
   mark#(repItems(X)) -> repItems#(mark(X))
   mark#(repItems(X)) -> active#(repItems(mark(X)))
   cons#(mark(X1),X2) -> cons#(X1,X2)
   cons#(X1,mark(X2)) -> cons#(X1,X2)
   cons#(active(X1),X2) -> cons#(X1,X2)
   cons#(X1,active(X2)) -> cons#(X1,X2)
   incr#(mark(X)) -> incr#(X)
   incr#(active(X)) -> incr#(X)
   s#(mark(X)) -> s#(X)
   s#(active(X)) -> s#(X)
   take#(mark(X1),X2) -> take#(X1,X2)
   take#(X1,mark(X2)) -> take#(X1,X2)
   take#(active(X1),X2) -> take#(X1,X2)
   take#(X1,active(X2)) -> take#(X1,X2)
   zip#(mark(X1),X2) -> zip#(X1,X2)
   zip#(X1,mark(X2)) -> zip#(X1,X2)
   zip#(active(X1),X2) -> zip#(X1,X2)
   zip#(X1,active(X2)) -> zip#(X1,X2)
   pair#(mark(X1),X2) -> pair#(X1,X2)
   pair#(X1,mark(X2)) -> pair#(X1,X2)
   pair#(active(X1),X2) -> pair#(X1,X2)
   pair#(X1,active(X2)) -> pair#(X1,X2)
   tail#(mark(X)) -> tail#(X)
   tail#(active(X)) -> tail#(X)
   repItems#(mark(X)) -> repItems#(X)
   repItems#(active(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))))
   mark(pairNs()) -> active(pairNs())
   mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
   mark(0()) -> active(0())
   mark(incr(X)) -> active(incr(mark(X)))
   mark(oddNs()) -> active(oddNs())
   mark(s(X)) -> active(s(mark(X)))
   mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
   mark(nil()) -> active(nil())
   mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
   mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
   mark(tail(X)) -> active(tail(mark(X)))
   mark(repItems(X)) -> active(repItems(mark(X)))
   cons(mark(X1),X2) -> cons(X1,X2)
   cons(X1,mark(X2)) -> cons(X1,X2)
   cons(active(X1),X2) -> cons(X1,X2)
   cons(X1,active(X2)) -> cons(X1,X2)
   incr(mark(X)) -> incr(X)
   incr(active(X)) -> incr(X)
   s(mark(X)) -> s(X)
   s(active(X)) -> s(X)
   take(mark(X1),X2) -> take(X1,X2)
   take(X1,mark(X2)) -> take(X1,X2)
   take(active(X1),X2) -> take(X1,X2)
   take(X1,active(X2)) -> take(X1,X2)
   zip(mark(X1),X2) -> zip(X1,X2)
   zip(X1,mark(X2)) -> zip(X1,X2)
   zip(active(X1),X2) -> zip(X1,X2)
   zip(X1,active(X2)) -> zip(X1,X2)
   pair(mark(X1),X2) -> pair(X1,X2)
   pair(X1,mark(X2)) -> pair(X1,X2)
   pair(active(X1),X2) -> pair(X1,X2)
   pair(X1,active(X2)) -> pair(X1,X2)
   tail(mark(X)) -> tail(X)
   tail(active(X)) -> tail(X)
   repItems(mark(X)) -> repItems(X)
   repItems(active(X)) -> repItems(X)
  TDG Processor:
   DPs:
    active#(pairNs()) -> incr#(oddNs())
    active#(pairNs()) -> cons#(0(),incr(oddNs()))
    active#(pairNs()) -> mark#(cons(0(),incr(oddNs())))
    active#(oddNs()) -> incr#(pairNs())
    active#(oddNs()) -> mark#(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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
    active#(take(0(),XS)) -> mark#(nil())
    active#(take(s(N),cons(X,XS))) -> take#(N,XS)
    active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
    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))) -> 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#(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))) -> repItems#(XS)
    active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
    active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
    active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
    mark#(pairNs()) -> active#(pairNs())
    mark#(cons(X1,X2)) -> mark#(X1)
    mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
    mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    mark#(0()) -> active#(0())
    mark#(incr(X)) -> mark#(X)
    mark#(incr(X)) -> incr#(mark(X))
    mark#(incr(X)) -> active#(incr(mark(X)))
    mark#(oddNs()) -> active#(oddNs())
    mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(take(X1,X2)) -> mark#(X2)
    mark#(take(X1,X2)) -> mark#(X1)
    mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
    mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
    mark#(nil()) -> active#(nil())
    mark#(zip(X1,X2)) -> mark#(X2)
    mark#(zip(X1,X2)) -> mark#(X1)
    mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
    mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
    mark#(pair(X1,X2)) -> mark#(X2)
    mark#(pair(X1,X2)) -> mark#(X1)
    mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
    mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
    mark#(tail(X)) -> mark#(X)
    mark#(tail(X)) -> tail#(mark(X))
    mark#(tail(X)) -> active#(tail(mark(X)))
    mark#(repItems(X)) -> mark#(X)
    mark#(repItems(X)) -> repItems#(mark(X))
    mark#(repItems(X)) -> active#(repItems(mark(X)))
    cons#(mark(X1),X2) -> cons#(X1,X2)
    cons#(X1,mark(X2)) -> cons#(X1,X2)
    cons#(active(X1),X2) -> cons#(X1,X2)
    cons#(X1,active(X2)) -> cons#(X1,X2)
    incr#(mark(X)) -> incr#(X)
    incr#(active(X)) -> incr#(X)
    s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X)
    take#(mark(X1),X2) -> take#(X1,X2)
    take#(X1,mark(X2)) -> take#(X1,X2)
    take#(active(X1),X2) -> take#(X1,X2)
    take#(X1,active(X2)) -> take#(X1,X2)
    zip#(mark(X1),X2) -> zip#(X1,X2)
    zip#(X1,mark(X2)) -> zip#(X1,X2)
    zip#(active(X1),X2) -> zip#(X1,X2)
    zip#(X1,active(X2)) -> zip#(X1,X2)
    pair#(mark(X1),X2) -> pair#(X1,X2)
    pair#(X1,mark(X2)) -> pair#(X1,X2)
    pair#(active(X1),X2) -> pair#(X1,X2)
    pair#(X1,active(X2)) -> pair#(X1,X2)
    tail#(mark(X)) -> tail#(X)
    tail#(active(X)) -> tail#(X)
    repItems#(mark(X)) -> repItems#(X)
    repItems#(active(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))))
    mark(pairNs()) -> active(pairNs())
    mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
    mark(0()) -> active(0())
    mark(incr(X)) -> active(incr(mark(X)))
    mark(oddNs()) -> active(oddNs())
    mark(s(X)) -> active(s(mark(X)))
    mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
    mark(nil()) -> active(nil())
    mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
    mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
    mark(tail(X)) -> active(tail(mark(X)))
    mark(repItems(X)) -> active(repItems(mark(X)))
    cons(mark(X1),X2) -> cons(X1,X2)
    cons(X1,mark(X2)) -> cons(X1,X2)
    cons(active(X1),X2) -> cons(X1,X2)
    cons(X1,active(X2)) -> cons(X1,X2)
    incr(mark(X)) -> incr(X)
    incr(active(X)) -> incr(X)
    s(mark(X)) -> s(X)
    s(active(X)) -> s(X)
    take(mark(X1),X2) -> take(X1,X2)
    take(X1,mark(X2)) -> take(X1,X2)
    take(active(X1),X2) -> take(X1,X2)
    take(X1,active(X2)) -> take(X1,X2)
    zip(mark(X1),X2) -> zip(X1,X2)
    zip(X1,mark(X2)) -> zip(X1,X2)
    zip(active(X1),X2) -> zip(X1,X2)
    zip(X1,active(X2)) -> zip(X1,X2)
    pair(mark(X1),X2) -> pair(X1,X2)
    pair(X1,mark(X2)) -> pair(X1,X2)
    pair(active(X1),X2) -> pair(X1,X2)
    pair(X1,active(X2)) -> pair(X1,X2)
    tail(mark(X)) -> tail(X)
    tail(active(X)) -> tail(X)
    repItems(mark(X)) -> repItems(X)
    repItems(active(X)) -> repItems(X)
   graph:
    ...
   EDG Processor:
    DPs:
     active#(pairNs()) -> incr#(oddNs())
     active#(pairNs()) -> cons#(0(),incr(oddNs()))
     active#(pairNs()) -> mark#(cons(0(),incr(oddNs())))
     active#(oddNs()) -> incr#(pairNs())
     active#(oddNs()) -> mark#(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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     active#(take(0(),XS)) -> mark#(nil())
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     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))) -> 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#(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))) -> repItems#(XS)
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(pairNs()) -> active#(pairNs())
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(0()) -> active#(0())
     mark#(incr(X)) -> mark#(X)
     mark#(incr(X)) -> incr#(mark(X))
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(oddNs()) -> active#(oddNs())
     mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> s#(mark(X))
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(nil()) -> active#(nil())
     mark#(zip(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(tail(X)) -> mark#(X)
     mark#(tail(X)) -> tail#(mark(X))
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(repItems(X)) -> mark#(X)
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2)
     incr#(mark(X)) -> incr#(X)
     incr#(active(X)) -> incr#(X)
     s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X)
     take#(mark(X1),X2) -> take#(X1,X2)
     take#(X1,mark(X2)) -> take#(X1,X2)
     take#(active(X1),X2) -> take#(X1,X2)
     take#(X1,active(X2)) -> take#(X1,X2)
     zip#(mark(X1),X2) -> zip#(X1,X2)
     zip#(X1,mark(X2)) -> zip#(X1,X2)
     zip#(active(X1),X2) -> zip#(X1,X2)
     zip#(X1,active(X2)) -> zip#(X1,X2)
     pair#(mark(X1),X2) -> pair#(X1,X2)
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     pair#(active(X1),X2) -> pair#(X1,X2)
     pair#(X1,active(X2)) -> pair#(X1,X2)
     tail#(mark(X)) -> tail#(X)
     tail#(active(X)) -> tail#(X)
     repItems#(mark(X)) -> repItems#(X)
     repItems#(active(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))))
     mark(pairNs()) -> active(pairNs())
     mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
     mark(0()) -> active(0())
     mark(incr(X)) -> active(incr(mark(X)))
     mark(oddNs()) -> active(oddNs())
     mark(s(X)) -> active(s(mark(X)))
     mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
     mark(nil()) -> active(nil())
     mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
     mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
     mark(tail(X)) -> active(tail(mark(X)))
     mark(repItems(X)) -> active(repItems(mark(X)))
     cons(mark(X1),X2) -> cons(X1,X2)
     cons(X1,mark(X2)) -> cons(X1,X2)
     cons(active(X1),X2) -> cons(X1,X2)
     cons(X1,active(X2)) -> cons(X1,X2)
     incr(mark(X)) -> incr(X)
     incr(active(X)) -> incr(X)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     take(mark(X1),X2) -> take(X1,X2)
     take(X1,mark(X2)) -> take(X1,X2)
     take(active(X1),X2) -> take(X1,X2)
     take(X1,active(X2)) -> take(X1,X2)
     zip(mark(X1),X2) -> zip(X1,X2)
     zip(X1,mark(X2)) -> zip(X1,X2)
     zip(active(X1),X2) -> zip(X1,X2)
     zip(X1,active(X2)) -> zip(X1,X2)
     pair(mark(X1),X2) -> pair(X1,X2)
     pair(X1,mark(X2)) -> pair(X1,X2)
     pair(active(X1),X2) -> pair(X1,X2)
     pair(X1,active(X2)) -> pair(X1,X2)
     tail(mark(X)) -> tail(X)
     tail(active(X)) -> tail(X)
     repItems(mark(X)) -> repItems(X)
     repItems(active(X)) -> repItems(X)
    graph:
     tail#(mark(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X)
     tail#(mark(X)) -> tail#(X) -> tail#(active(X)) -> tail#(X)
     tail#(active(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X)
     tail#(active(X)) -> tail#(X) -> tail#(active(X)) -> tail#(X)
     repItems#(mark(X)) -> repItems#(X) ->
     repItems#(mark(X)) -> repItems#(X)
     repItems#(mark(X)) -> repItems#(X) ->
     repItems#(active(X)) -> repItems#(X)
     repItems#(active(X)) -> repItems#(X) ->
     repItems#(mark(X)) -> repItems#(X)
     repItems#(active(X)) -> repItems#(X) ->
     repItems#(active(X)) -> repItems#(X)
     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#(active(X1),X2) -> pair#(X1,X2)
     pair#(mark(X1),X2) -> pair#(X1,X2) ->
     pair#(X1,active(X2)) -> pair#(X1,X2)
     pair#(active(X1),X2) -> pair#(X1,X2) ->
     pair#(mark(X1),X2) -> pair#(X1,X2)
     pair#(active(X1),X2) -> pair#(X1,X2) ->
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     pair#(active(X1),X2) -> pair#(X1,X2) ->
     pair#(active(X1),X2) -> pair#(X1,X2)
     pair#(active(X1),X2) -> pair#(X1,X2) ->
     pair#(X1,active(X2)) -> pair#(X1,X2)
     pair#(X1,mark(X2)) -> pair#(X1,X2) ->
     pair#(mark(X1),X2) -> pair#(X1,X2)
     pair#(X1,mark(X2)) -> pair#(X1,X2) ->
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     pair#(X1,mark(X2)) -> pair#(X1,X2) ->
     pair#(active(X1),X2) -> pair#(X1,X2)
     pair#(X1,mark(X2)) -> pair#(X1,X2) ->
     pair#(X1,active(X2)) -> pair#(X1,X2)
     pair#(X1,active(X2)) -> pair#(X1,X2) ->
     pair#(mark(X1),X2) -> pair#(X1,X2)
     pair#(X1,active(X2)) -> pair#(X1,X2) ->
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     pair#(X1,active(X2)) -> pair#(X1,X2) ->
     pair#(active(X1),X2) -> pair#(X1,X2)
     pair#(X1,active(X2)) -> pair#(X1,X2) ->
     pair#(X1,active(X2)) -> pair#(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#(active(X1),X2) -> zip#(X1,X2)
     zip#(mark(X1),X2) -> zip#(X1,X2) ->
     zip#(X1,active(X2)) -> zip#(X1,X2)
     zip#(active(X1),X2) -> zip#(X1,X2) ->
     zip#(mark(X1),X2) -> zip#(X1,X2)
     zip#(active(X1),X2) -> zip#(X1,X2) ->
     zip#(X1,mark(X2)) -> zip#(X1,X2)
     zip#(active(X1),X2) -> zip#(X1,X2) ->
     zip#(active(X1),X2) -> zip#(X1,X2)
     zip#(active(X1),X2) -> zip#(X1,X2) ->
     zip#(X1,active(X2)) -> zip#(X1,X2)
     zip#(X1,mark(X2)) -> zip#(X1,X2) ->
     zip#(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#(active(X1),X2) -> zip#(X1,X2)
     zip#(X1,mark(X2)) -> zip#(X1,X2) ->
     zip#(X1,active(X2)) -> zip#(X1,X2)
     zip#(X1,active(X2)) -> zip#(X1,X2) ->
     zip#(mark(X1),X2) -> zip#(X1,X2)
     zip#(X1,active(X2)) -> zip#(X1,X2) ->
     zip#(X1,mark(X2)) -> zip#(X1,X2)
     zip#(X1,active(X2)) -> zip#(X1,X2) ->
     zip#(active(X1),X2) -> zip#(X1,X2)
     zip#(X1,active(X2)) -> zip#(X1,X2) ->
     zip#(X1,active(X2)) -> zip#(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#(active(X1),X2) -> take#(X1,X2)
     take#(mark(X1),X2) -> take#(X1,X2) ->
     take#(X1,active(X2)) -> take#(X1,X2)
     take#(active(X1),X2) -> take#(X1,X2) ->
     take#(mark(X1),X2) -> take#(X1,X2)
     take#(active(X1),X2) -> take#(X1,X2) ->
     take#(X1,mark(X2)) -> take#(X1,X2)
     take#(active(X1),X2) -> take#(X1,X2) ->
     take#(active(X1),X2) -> take#(X1,X2)
     take#(active(X1),X2) -> take#(X1,X2) ->
     take#(X1,active(X2)) -> take#(X1,X2)
     take#(X1,mark(X2)) -> take#(X1,X2) ->
     take#(mark(X1),X2) -> take#(X1,X2)
     take#(X1,mark(X2)) -> take#(X1,X2) ->
     take#(X1,mark(X2)) -> take#(X1,X2)
     take#(X1,mark(X2)) -> take#(X1,X2) ->
     take#(active(X1),X2) -> take#(X1,X2)
     take#(X1,mark(X2)) -> take#(X1,X2) ->
     take#(X1,active(X2)) -> take#(X1,X2)
     take#(X1,active(X2)) -> take#(X1,X2) ->
     take#(mark(X1),X2) -> take#(X1,X2)
     take#(X1,active(X2)) -> take#(X1,X2) ->
     take#(X1,mark(X2)) -> take#(X1,X2)
     take#(X1,active(X2)) -> take#(X1,X2) ->
     take#(active(X1),X2) -> take#(X1,X2)
     take#(X1,active(X2)) -> take#(X1,X2) ->
     take#(X1,active(X2)) -> take#(X1,X2)
     s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
     s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
     s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
     mark#(repItems(X)) -> repItems#(mark(X)) ->
     repItems#(mark(X)) -> repItems#(X)
     mark#(repItems(X)) -> repItems#(mark(X)) ->
     repItems#(active(X)) -> repItems#(X)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(repItems(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(repItems(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(repItems(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(repItems(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(repItems(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(repItems(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
     mark#(repItems(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2)
     mark#(repItems(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(repItems(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(repItems(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X)
     mark#(repItems(X)) -> mark#(X) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(repItems(X)) -> mark#(X) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(repItems(X)) -> active#(repItems(mark(X))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(tail(X)) -> tail#(mark(X)) -> tail#(mark(X)) -> tail#(X)
     mark#(tail(X)) -> tail#(mark(X)) -> tail#(active(X)) -> tail#(X)
     mark#(tail(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs())
     mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
     mark#(tail(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(tail(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(tail(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X)
     mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X))
     mark#(tail(X)) -> mark#(X) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(tail(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs())
     mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
     mark#(tail(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2)
     mark#(tail(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1)
     mark#(tail(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(tail(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(tail(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
     mark#(tail(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2)
     mark#(tail(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1)
     mark#(tail(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(tail(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(tail(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2)
     mark#(tail(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1)
     mark#(tail(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(tail(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X)
     mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X))
     mark#(tail(X)) -> mark#(X) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(tail(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X)
     mark#(tail(X)) -> mark#(X) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(tail(X)) -> mark#(X) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(tail(X)) -> active#(tail(mark(X))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) ->
     pair#(mark(X1),X2) -> pair#(X1,X2)
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) ->
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) ->
     pair#(active(X1),X2) -> pair#(X1,X2)
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) ->
     pair#(X1,active(X2)) -> pair#(X1,X2)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(pair(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
     mark#(pair(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(pair(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(nil()) -> active#(nil())
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(pair(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
     mark#(pair(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(pair(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(nil()) -> active#(nil())
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(pair(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> mark#(X)
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(pair(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) ->
     zip#(mark(X1),X2) -> zip#(X1,X2)
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) ->
     zip#(X1,mark(X2)) -> zip#(X1,X2)
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) ->
     zip#(active(X1),X2) -> zip#(X1,X2)
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) ->
     zip#(X1,active(X2)) -> zip#(X1,X2)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(nil()) -> active#(nil())
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil())
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(zip(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X)
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(zip(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) ->
     take#(mark(X1),X2) -> take#(X1,X2)
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) ->
     take#(X1,mark(X2)) -> take#(X1,X2)
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) ->
     take#(active(X1),X2) -> take#(X1,X2)
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) ->
     take#(X1,active(X2)) -> take#(X1,X2)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(take(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
     mark#(take(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(nil()) -> active#(nil())
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(take(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(take(X1,X2)) -> mark#(X2) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(take(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
     mark#(take(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(nil()) -> active#(nil())
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(take(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> mark#(X)
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(take(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
     mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
     mark#(s(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs())
     mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(s(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X))
     mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(s(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs())
     mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
     mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2)
     mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(s(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
     mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2)
     mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(s(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(s(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2)
     mark#(s(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(s(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X))
     mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(s(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X)
     mark#(s(X)) -> mark#(X) -> mark#(repItems(X)) -> repItems#(mark(X))
     mark#(s(X)) -> mark#(X) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(pairNs()) -> active#(pairNs())
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> incr#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(oddNs()) -> active#(oddNs())
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(s(X)) -> active#(s(mark(X)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X2)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(nil()) -> active#(nil())
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> tail#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> mark#(X)
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(cons(X1,X2)) -> mark#(X1) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(incr(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs())
     mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1)
     mark#(incr(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     mark#(incr(X)) -> mark#(X) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     mark#(incr(X)) -> mark#(X) -> mark#(0()) -> active#(0())
     mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X)
     mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X))
     mark#(incr(X)) -> mark#(X) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     mark#(incr(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs())
     mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
     mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
     mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
     mark#(incr(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2)
     mark#(incr(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1)
     mark#(incr(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     mark#(incr(X)) -> mark#(X) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     mark#(incr(X)) -> mark#(X) -> mark#(nil()) -> active#(nil())
     mark#(incr(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2)
     mark#(incr(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1)
     mark#(incr(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     mark#(incr(X)) -> mark#(X) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     mark#(incr(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2)
     mark#(incr(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1)
     mark#(incr(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     mark#(incr(X)) -> mark#(X) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X)
     mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X))
     mark#(incr(X)) -> mark#(X) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     mark#(incr(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X)
     mark#(incr(X)) -> mark#(X) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     mark#(incr(X)) -> mark#(X) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     mark#(incr(X)) -> incr#(mark(X)) -> incr#(mark(X)) -> incr#(X)
     mark#(incr(X)) -> incr#(mark(X)) ->
     incr#(active(X)) -> incr#(X)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(incr(cons(X,XS))) -> incr#(XS)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(incr(cons(X,XS))) -> s#(X)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(take(0(),XS)) -> mark#(nil())
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> take#(N,XS)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(zip(nil(),XS)) -> mark#(nil())
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(zip(X,nil())) -> mark#(nil())
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(tail(cons(X,XS))) -> mark#(XS)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(repItems(nil())) -> mark#(nil())
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(repItems(cons(X,XS))) -> repItems#(XS)
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
     mark#(incr(X)) -> active#(incr(mark(X))) ->
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
     mark#(oddNs()) -> active#(oddNs()) ->
     active#(oddNs()) -> incr#(pairNs())
     mark#(oddNs()) -> active#(oddNs()) ->
     active#(oddNs()) -> mark#(incr(pairNs()))
     mark#(pairNs()) -> active#(pairNs()) ->
     active#(pairNs()) -> incr#(oddNs())
     mark#(pairNs()) -> active#(pairNs()) ->
     active#(pairNs()) -> cons#(0(),incr(oddNs()))
     mark#(pairNs()) -> active#(pairNs()) ->
     active#(pairNs()) -> mark#(cons(0(),incr(oddNs())))
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(mark(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(active(X1),X2) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,mark(X2)) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     cons#(X1,active(X2)) -> cons#(X1,X2) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     incr#(mark(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X)
     incr#(mark(X)) -> incr#(X) -> incr#(active(X)) -> incr#(X)
     incr#(active(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X)
     incr#(active(X)) -> incr#(X) ->
     incr#(active(X)) -> incr#(X)
     active#(repItems(nil())) -> mark#(nil()) ->
     mark#(nil()) -> active#(nil())
     active#(repItems(cons(X,XS))) -> repItems#(XS) ->
     repItems#(mark(X)) -> repItems#(X)
     active#(repItems(cons(X,XS))) -> repItems#(XS) ->
     repItems#(active(X)) -> repItems#(X)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(incr(X)) -> mark#(X)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(incr(X)) -> incr#(mark(X))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(s(X)) -> mark#(X)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(take(X1,X2)) -> mark#(X2)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(take(X1,X2)) -> mark#(X1)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(tail(X)) -> mark#(X)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(tail(X)) -> tail#(mark(X))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(repItems(X)) -> mark#(X)
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(pairNs()) -> active#(pairNs())
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(0()) -> active#(0())
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(incr(X)) -> mark#(X)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(incr(X)) -> incr#(mark(X))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(oddNs()) -> active#(oddNs())
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(s(X)) -> mark#(X)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(s(X)) -> s#(mark(X))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(take(X1,X2)) -> mark#(X2)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(take(X1,X2)) -> mark#(X1)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(nil()) -> active#(nil())
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(tail(X)) -> mark#(X)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(tail(X)) -> tail#(mark(X))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(repItems(X)) -> mark#(X)
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     active#(tail(cons(X,XS))) -> mark#(XS) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     active#(zip(nil(),XS)) -> mark#(nil()) ->
     mark#(nil()) -> active#(nil())
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) ->
     pair#(mark(X1),X2) -> pair#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) ->
     pair#(X1,mark(X2)) -> pair#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) ->
     pair#(active(X1),X2) -> pair#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) ->
     pair#(X1,active(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#(active(X1),X2) -> zip#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS) ->
     zip#(X1,active(X2)) -> zip#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(incr(X)) -> mark#(X)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(incr(X)) -> incr#(mark(X))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(s(X)) -> mark#(X)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(take(X1,X2)) -> mark#(X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(take(X1,X2)) -> mark#(X1)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(tail(X)) -> mark#(X)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(tail(X)) -> tail#(mark(X))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(repItems(X)) -> mark#(X)
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(zip(X,nil())) -> mark#(nil()) ->
     mark#(nil()) -> active#(nil())
     active#(take(s(N),cons(X,XS))) -> take#(N,XS) ->
     take#(mark(X1),X2) -> take#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> take#(N,XS) ->
     take#(X1,mark(X2)) -> take#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> take#(N,XS) ->
     take#(active(X1),X2) -> take#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> take#(N,XS) ->
     take#(X1,active(X2)) -> take#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(incr(X)) -> mark#(X)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(incr(X)) -> incr#(mark(X))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(s(X)) -> mark#(X)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(take(X1,X2)) -> mark#(X2)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(take(X1,X2)) -> mark#(X1)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(tail(X)) -> mark#(X)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(tail(X)) -> tail#(mark(X))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(repItems(X)) -> mark#(X)
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS))) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS)) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS)) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(take(0(),XS)) -> mark#(nil()) ->
     mark#(nil()) -> active#(nil())
     active#(incr(cons(X,XS))) -> s#(X) -> s#(mark(X)) -> s#(X)
     active#(incr(cons(X,XS))) -> s#(X) ->
     s#(active(X)) -> s#(X)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(incr(X)) -> mark#(X)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(incr(X)) -> incr#(mark(X))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(s(X)) -> mark#(X)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(s(X)) -> s#(mark(X))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(s(X)) -> active#(s(mark(X)))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(take(X1,X2)) -> mark#(X2)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(take(X1,X2)) -> mark#(X1)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(zip(X1,X2)) -> mark#(X2)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(zip(X1,X2)) -> mark#(X1)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(pair(X1,X2)) -> mark#(X2)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(pair(X1,X2)) -> mark#(X1)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(tail(X)) -> mark#(X)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(tail(X)) -> tail#(mark(X))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(tail(X)) -> active#(tail(mark(X)))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(repItems(X)) -> mark#(X)
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(repItems(X)) -> repItems#(mark(X))
     active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) ->
     mark#(repItems(X)) -> active#(repItems(mark(X)))
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) ->
     cons#(mark(X1),X2) -> cons#(X1,X2)
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) ->
     cons#(X1,mark(X2)) -> cons#(X1,X2)
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) ->
     cons#(active(X1),X2) -> cons#(X1,X2)
     active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) ->
     cons#(X1,active(X2)) -> cons#(X1,X2)
     active#(incr(cons(X,XS))) -> incr#(XS) ->
     incr#(mark(X)) -> incr#(X)
     active#(incr(cons(X,XS))) -> incr#(XS) ->
     incr#(active(X)) -> incr#(X)
     active#(oddNs()) -> mark#(incr(pairNs())) ->
     mark#(incr(X)) -> mark#(X)
     active#(oddNs()) -> mark#(incr(pairNs())) ->
     mark#(incr(X)) -> incr#(mark(X))
     active#(oddNs()) -> mark#(incr(pairNs())) ->
     mark#(incr(X)) -> active#(incr(mark(X)))
     active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) ->
     mark#(cons(X1,X2)) -> mark#(X1)
     active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) ->
     mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
     active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) ->
     mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
    Restore Modifier:
     DPs:
      active#(pairNs()) -> incr#(oddNs())
      active#(pairNs()) -> cons#(0(),incr(oddNs()))
      active#(pairNs()) -> mark#(cons(0(),incr(oddNs())))
      active#(oddNs()) -> incr#(pairNs())
      active#(oddNs()) -> mark#(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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
      active#(take(0(),XS)) -> mark#(nil())
      active#(take(s(N),cons(X,XS))) -> take#(N,XS)
      active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
      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))) -> 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#(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))) -> repItems#(XS)
      active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
      active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
      active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
      mark#(pairNs()) -> active#(pairNs())
      mark#(cons(X1,X2)) -> mark#(X1)
      mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
      mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
      mark#(0()) -> active#(0())
      mark#(incr(X)) -> mark#(X)
      mark#(incr(X)) -> incr#(mark(X))
      mark#(incr(X)) -> active#(incr(mark(X)))
      mark#(oddNs()) -> active#(oddNs())
      mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> s#(mark(X))
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(take(X1,X2)) -> mark#(X2)
      mark#(take(X1,X2)) -> mark#(X1)
      mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
      mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
      mark#(nil()) -> active#(nil())
      mark#(zip(X1,X2)) -> mark#(X2)
      mark#(zip(X1,X2)) -> mark#(X1)
      mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
      mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
      mark#(pair(X1,X2)) -> mark#(X2)
      mark#(pair(X1,X2)) -> mark#(X1)
      mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
      mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
      mark#(tail(X)) -> mark#(X)
      mark#(tail(X)) -> tail#(mark(X))
      mark#(tail(X)) -> active#(tail(mark(X)))
      mark#(repItems(X)) -> mark#(X)
      mark#(repItems(X)) -> repItems#(mark(X))
      mark#(repItems(X)) -> active#(repItems(mark(X)))
      cons#(mark(X1),X2) -> cons#(X1,X2)
      cons#(X1,mark(X2)) -> cons#(X1,X2)
      cons#(active(X1),X2) -> cons#(X1,X2)
      cons#(X1,active(X2)) -> cons#(X1,X2)
      incr#(mark(X)) -> incr#(X)
      incr#(active(X)) -> incr#(X)
      s#(mark(X)) -> s#(X)
      s#(active(X)) -> s#(X)
      take#(mark(X1),X2) -> take#(X1,X2)
      take#(X1,mark(X2)) -> take#(X1,X2)
      take#(active(X1),X2) -> take#(X1,X2)
      take#(X1,active(X2)) -> take#(X1,X2)
      zip#(mark(X1),X2) -> zip#(X1,X2)
      zip#(X1,mark(X2)) -> zip#(X1,X2)
      zip#(active(X1),X2) -> zip#(X1,X2)
      zip#(X1,active(X2)) -> zip#(X1,X2)
      pair#(mark(X1),X2) -> pair#(X1,X2)
      pair#(X1,mark(X2)) -> pair#(X1,X2)
      pair#(active(X1),X2) -> pair#(X1,X2)
      pair#(X1,active(X2)) -> pair#(X1,X2)
      tail#(mark(X)) -> tail#(X)
      tail#(active(X)) -> tail#(X)
      repItems#(mark(X)) -> repItems#(X)
      repItems#(active(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))))
      mark(pairNs()) -> active(pairNs())
      mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
      mark(0()) -> active(0())
      mark(incr(X)) -> active(incr(mark(X)))
      mark(oddNs()) -> active(oddNs())
      mark(s(X)) -> active(s(mark(X)))
      mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
      mark(nil()) -> active(nil())
      mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
      mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
      mark(tail(X)) -> active(tail(mark(X)))
      mark(repItems(X)) -> active(repItems(mark(X)))
      cons(mark(X1),X2) -> cons(X1,X2)
      cons(X1,mark(X2)) -> cons(X1,X2)
      cons(active(X1),X2) -> cons(X1,X2)
      cons(X1,active(X2)) -> cons(X1,X2)
      incr(mark(X)) -> incr(X)
      incr(active(X)) -> incr(X)
      s(mark(X)) -> s(X)
      s(active(X)) -> s(X)
      take(mark(X1),X2) -> take(X1,X2)
      take(X1,mark(X2)) -> take(X1,X2)
      take(active(X1),X2) -> take(X1,X2)
      take(X1,active(X2)) -> take(X1,X2)
      zip(mark(X1),X2) -> zip(X1,X2)
      zip(X1,mark(X2)) -> zip(X1,X2)
      zip(active(X1),X2) -> zip(X1,X2)
      zip(X1,active(X2)) -> zip(X1,X2)
      pair(mark(X1),X2) -> pair(X1,X2)
      pair(X1,mark(X2)) -> pair(X1,X2)
      pair(active(X1),X2) -> pair(X1,X2)
      pair(X1,active(X2)) -> pair(X1,X2)
      tail(mark(X)) -> tail(X)
      tail(active(X)) -> tail(X)
      repItems(mark(X)) -> repItems(X)
      repItems(active(X)) -> repItems(X)
     SCC Processor:
      #sccs: 9
      #rules: 52
      #arcs: 797/6400
      DPs:
       mark#(repItems(X)) -> mark#(X)
       mark#(repItems(X)) -> active#(repItems(mark(X)))
       active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
       mark#(tail(X)) -> active#(tail(mark(X)))
       active#(tail(cons(X,XS))) -> mark#(XS)
       mark#(tail(X)) -> mark#(X)
       mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
       active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
       mark#(pair(X1,X2)) -> mark#(X1)
       mark#(pair(X1,X2)) -> mark#(X2)
       mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
       active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
       mark#(zip(X1,X2)) -> mark#(X1)
       mark#(zip(X1,X2)) -> mark#(X2)
       mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
       active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
       mark#(take(X1,X2)) -> mark#(X1)
       mark#(take(X1,X2)) -> mark#(X2)
       mark#(s(X)) -> active#(s(mark(X)))
       mark#(s(X)) -> mark#(X)
       mark#(oddNs()) -> active#(oddNs())
       active#(oddNs()) -> mark#(incr(pairNs()))
       mark#(incr(X)) -> active#(incr(mark(X)))
       mark#(incr(X)) -> mark#(X)
       mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
       mark#(cons(X1,X2)) -> mark#(X1)
       mark#(pairNs()) -> active#(pairNs())
       active#(pairNs()) -> mark#(cons(0(),incr(oddNs())))
      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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       incr#(active(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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       cons#(X1,active(X2)) -> cons#(X1,X2)
       cons#(active(X1),X2) -> cons#(X1,X2)
       cons#(X1,mark(X2)) -> cons#(X1,X2)
       cons#(mark(X1),X2) -> cons#(X1,X2)
      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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       s#(mark(X)) -> s#(X)
       s#(active(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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       take#(mark(X1),X2) -> take#(X1,X2)
       take#(X1,active(X2)) -> take#(X1,X2)
       take#(active(X1),X2) -> take#(X1,X2)
       take#(X1,mark(X2)) -> take#(X1,X2)
      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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       zip#(mark(X1),X2) -> zip#(X1,X2)
       zip#(X1,active(X2)) -> zip#(X1,X2)
       zip#(active(X1),X2) -> zip#(X1,X2)
       zip#(X1,mark(X2)) -> zip#(X1,X2)
      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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       pair#(mark(X1),X2) -> pair#(X1,X2)
       pair#(X1,active(X2)) -> pair#(X1,X2)
       pair#(active(X1),X2) -> pair#(X1,X2)
       pair#(X1,mark(X2)) -> pair#(X1,X2)
      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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       repItems#(mark(X)) -> repItems#(X)
       repItems#(active(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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open
      
      DPs:
       tail#(mark(X)) -> tail#(X)
       tail#(active(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))))
       mark(pairNs()) -> active(pairNs())
       mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
       mark(0()) -> active(0())
       mark(incr(X)) -> active(incr(mark(X)))
       mark(oddNs()) -> active(oddNs())
       mark(s(X)) -> active(s(mark(X)))
       mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
       mark(nil()) -> active(nil())
       mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
       mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
       mark(tail(X)) -> active(tail(mark(X)))
       mark(repItems(X)) -> active(repItems(mark(X)))
       cons(mark(X1),X2) -> cons(X1,X2)
       cons(X1,mark(X2)) -> cons(X1,X2)
       cons(active(X1),X2) -> cons(X1,X2)
       cons(X1,active(X2)) -> cons(X1,X2)
       incr(mark(X)) -> incr(X)
       incr(active(X)) -> incr(X)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       take(mark(X1),X2) -> take(X1,X2)
       take(X1,mark(X2)) -> take(X1,X2)
       take(active(X1),X2) -> take(X1,X2)
       take(X1,active(X2)) -> take(X1,X2)
       zip(mark(X1),X2) -> zip(X1,X2)
       zip(X1,mark(X2)) -> zip(X1,X2)
       zip(active(X1),X2) -> zip(X1,X2)
       zip(X1,active(X2)) -> zip(X1,X2)
       pair(mark(X1),X2) -> pair(X1,X2)
       pair(X1,mark(X2)) -> pair(X1,X2)
       pair(active(X1),X2) -> pair(X1,X2)
       pair(X1,active(X2)) -> pair(X1,X2)
       tail(mark(X)) -> tail(X)
       tail(active(X)) -> tail(X)
       repItems(mark(X)) -> repItems(X)
       repItems(active(X)) -> repItems(X)
      Open