/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


NO

Problem 1: 

(VAR N X X1 X2 XS Y YS)
(RULES
activate(n__cons(X1,X2)) -> cons(X1,X2)
activate(n__incr(X)) -> incr(X)
activate(n__repItems(X)) -> repItems(X)
activate(n__take(X1,X2)) -> take(X1,X2)
activate(n__zip(X1,X2)) -> zip(X1,X2)
activate(X) -> X
cons(X1,X2) -> n__cons(X1,X2)
incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
incr(X) -> n__incr(X)
oddNs -> incr(pairNs)
pairNs -> cons(0,n__incr(oddNs))
repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
repItems(nil) -> nil
repItems(X) -> n__repItems(X)
tail(cons(X,XS)) -> activate(XS)
take(0,XS) -> nil
take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
take(X1,X2) -> n__take(X1,X2)
zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
zip(nil,XS) -> nil
zip(X,nil) -> nil
zip(X1,X2) -> n__zip(X1,X2)
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 ACTIVATE(n__cons(X1,X2)) -> CONS(X1,X2)
 ACTIVATE(n__incr(X)) -> INCR(X)
 ACTIVATE(n__repItems(X)) -> REPITEMS(X)
 ACTIVATE(n__take(X1,X2)) -> TAKE(X1,X2)
 ACTIVATE(n__zip(X1,X2)) -> ZIP(X1,X2)
 INCR(cons(X,XS)) -> ACTIVATE(XS)
 INCR(cons(X,XS)) -> CONS(s(X),n__incr(activate(XS)))
 ODDNS -> INCR(pairNs)
 ODDNS -> PAIRNS
 PAIRNS -> CONS(0,n__incr(oddNs))
 PAIRNS -> ODDNS
 REPITEMS(cons(X,XS)) -> ACTIVATE(XS)
 REPITEMS(cons(X,XS)) -> CONS(X,n__cons(X,n__repItems(activate(XS))))
 TAIL(cons(X,XS)) -> ACTIVATE(XS)
 TAKE(s(N),cons(X,XS)) -> ACTIVATE(XS)
 TAKE(s(N),cons(X,XS)) -> CONS(X,n__take(N,activate(XS)))
 ZIP(cons(X,XS),cons(Y,YS)) -> ACTIVATE(XS)
 ZIP(cons(X,XS),cons(Y,YS)) -> ACTIVATE(YS)
 ZIP(cons(X,XS),cons(Y,YS)) -> CONS(pair(X,Y),n__zip(activate(XS),activate(YS)))
-> Rules:
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__incr(X)) -> incr(X)
 activate(n__repItems(X)) -> repItems(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(X) -> X
 cons(X1,X2) -> n__cons(X1,X2)
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 incr(X) -> n__incr(X)
 oddNs -> incr(pairNs)
 pairNs -> cons(0,n__incr(oddNs))
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 repItems(nil) -> nil
 repItems(X) -> n__repItems(X)
 tail(cons(X,XS)) -> activate(XS)
 take(0,XS) -> nil
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 take(X1,X2) -> n__take(X1,X2)
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 zip(nil,XS) -> nil
 zip(X,nil) -> nil
 zip(X1,X2) -> n__zip(X1,X2)

Problem 1: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__cons(X1,X2)) -> CONS(X1,X2)
 ACTIVATE(n__incr(X)) -> INCR(X)
 ACTIVATE(n__repItems(X)) -> REPITEMS(X)
 ACTIVATE(n__take(X1,X2)) -> TAKE(X1,X2)
 ACTIVATE(n__zip(X1,X2)) -> ZIP(X1,X2)
 INCR(cons(X,XS)) -> ACTIVATE(XS)
 INCR(cons(X,XS)) -> CONS(s(X),n__incr(activate(XS)))
 ODDNS -> INCR(pairNs)
 ODDNS -> PAIRNS
 PAIRNS -> CONS(0,n__incr(oddNs))
 PAIRNS -> ODDNS
 REPITEMS(cons(X,XS)) -> ACTIVATE(XS)
 REPITEMS(cons(X,XS)) -> CONS(X,n__cons(X,n__repItems(activate(XS))))
 TAIL(cons(X,XS)) -> ACTIVATE(XS)
 TAKE(s(N),cons(X,XS)) -> ACTIVATE(XS)
 TAKE(s(N),cons(X,XS)) -> CONS(X,n__take(N,activate(XS)))
 ZIP(cons(X,XS),cons(Y,YS)) -> ACTIVATE(XS)
 ZIP(cons(X,XS),cons(Y,YS)) -> ACTIVATE(YS)
 ZIP(cons(X,XS),cons(Y,YS)) -> CONS(pair(X,Y),n__zip(activate(XS),activate(YS)))
-> Rules:
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__incr(X)) -> incr(X)
 activate(n__repItems(X)) -> repItems(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(X) -> X
 cons(X1,X2) -> n__cons(X1,X2)
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 incr(X) -> n__incr(X)
 oddNs -> incr(pairNs)
 pairNs -> cons(0,n__incr(oddNs))
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 repItems(nil) -> nil
 repItems(X) -> n__repItems(X)
 tail(cons(X,XS)) -> activate(XS)
 take(0,XS) -> nil
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 take(X1,X2) -> n__take(X1,X2)
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 zip(nil,XS) -> nil
 zip(X,nil) -> nil
 zip(X1,X2) -> n__zip(X1,X2)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__incr(X)) -> INCR(X)
 ACTIVATE(n__repItems(X)) -> REPITEMS(X)
 ACTIVATE(n__take(X1,X2)) -> TAKE(X1,X2)
 ACTIVATE(n__zip(X1,X2)) -> ZIP(X1,X2)
 INCR(cons(X,XS)) -> ACTIVATE(XS)
 REPITEMS(cons(X,XS)) -> ACTIVATE(XS)
 TAKE(s(N),cons(X,XS)) -> ACTIVATE(XS)
 ZIP(cons(X,XS),cons(Y,YS)) -> ACTIVATE(XS)
 ZIP(cons(X,XS),cons(Y,YS)) -> ACTIVATE(YS)
->->-> Rules:
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__incr(X)) -> incr(X)
 activate(n__repItems(X)) -> repItems(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(X) -> X
 cons(X1,X2) -> n__cons(X1,X2)
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 incr(X) -> n__incr(X)
 oddNs -> incr(pairNs)
 pairNs -> cons(0,n__incr(oddNs))
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 repItems(nil) -> nil
 repItems(X) -> n__repItems(X)
 tail(cons(X,XS)) -> activate(XS)
 take(0,XS) -> nil
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 take(X1,X2) -> n__take(X1,X2)
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 zip(nil,XS) -> nil
 zip(X,nil) -> nil
 zip(X1,X2) -> n__zip(X1,X2)
->->Cycle:
->->-> Pairs:
 ODDNS -> PAIRNS
 PAIRNS -> ODDNS
->->-> Rules:
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__incr(X)) -> incr(X)
 activate(n__repItems(X)) -> repItems(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(X) -> X
 cons(X1,X2) -> n__cons(X1,X2)
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 incr(X) -> n__incr(X)
 oddNs -> incr(pairNs)
 pairNs -> cons(0,n__incr(oddNs))
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 repItems(nil) -> nil
 repItems(X) -> n__repItems(X)
 tail(cons(X,XS)) -> activate(XS)
 take(0,XS) -> nil
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 take(X1,X2) -> n__take(X1,X2)
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 zip(nil,XS) -> nil
 zip(X,nil) -> nil
 zip(X1,X2) -> n__zip(X1,X2)

Problem 1: 

Infinite Processor:
-> Pairs:
 ODDNS -> PAIRNS
 PAIRNS -> ODDNS
-> Rules:
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__incr(X)) -> incr(X)
 activate(n__repItems(X)) -> repItems(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(X) -> X
 cons(X1,X2) -> n__cons(X1,X2)
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 incr(X) -> n__incr(X)
 oddNs -> incr(pairNs)
 pairNs -> cons(0,n__incr(oddNs))
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 repItems(nil) -> nil
 repItems(X) -> n__repItems(X)
 tail(cons(X,XS)) -> activate(XS)
 take(0,XS) -> nil
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 take(X1,X2) -> n__take(X1,X2)
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 zip(nil,XS) -> nil
 zip(X,nil) -> nil
 zip(X1,X2) -> n__zip(X1,X2)
-> Pairs in cycle:
 ODDNS -> PAIRNS
 PAIRNS -> ODDNS

The problem is infinite.