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


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


NO

Problem 1: 

(VAR IL L M N X X1 X2)
(RULES
activate(n__take(X1,X2)) -> take(X1,X2)
activate(n__zeros) -> zeros
activate(X) -> X
and(tt,X) -> activate(X)
length(cons(N,L)) -> s(length(activate(L)))
length(nil) -> 0
take(0,IL) -> nil
take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
take(X1,X2) -> n__take(X1,X2)
zeros -> cons(0,n__zeros)
zeros -> n__zeros
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 ACTIVATE(n__take(X1,X2)) -> TAKE(X1,X2)
 ACTIVATE(n__zeros) -> ZEROS
 AND(tt,X) -> ACTIVATE(X)
 LENGTH(cons(N,L)) -> ACTIVATE(L)
 LENGTH(cons(N,L)) -> LENGTH(activate(L))
 TAKE(s(M),cons(N,IL)) -> ACTIVATE(IL)
-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros

Problem 1: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__take(X1,X2)) -> TAKE(X1,X2)
 ACTIVATE(n__zeros) -> ZEROS
 AND(tt,X) -> ACTIVATE(X)
 LENGTH(cons(N,L)) -> ACTIVATE(L)
 LENGTH(cons(N,L)) -> LENGTH(activate(L))
 TAKE(s(M),cons(N,IL)) -> ACTIVATE(IL)
-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__take(X1,X2)) -> TAKE(X1,X2)
 TAKE(s(M),cons(N,IL)) -> ACTIVATE(IL)
->->-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros
->->Cycle:
->->-> Pairs:
 LENGTH(cons(N,L)) -> LENGTH(activate(L))
->->-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros

Problem 1: 

Narrowing Processor:
-> Pairs:
 LENGTH(cons(N,L)) -> LENGTH(activate(L))
-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros
->Narrowed Pairs:
->->Original Pair:
 LENGTH(cons(N,L)) -> LENGTH(activate(L))
->-> Narrowed pairs:
 LENGTH(cons(x8,n__take(X1,X2))) -> LENGTH(take(X1,X2))
 LENGTH(cons(x8,n__zeros)) -> LENGTH(zeros)
 LENGTH(cons(x8,X)) -> LENGTH(X)

Problem 1: 

SCC Processor:
-> Pairs:
 LENGTH(cons(x8,n__take(X1,X2))) -> LENGTH(take(X1,X2))
 LENGTH(cons(x8,n__zeros)) -> LENGTH(zeros)
 LENGTH(cons(x8,X)) -> LENGTH(X)
-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 LENGTH(cons(x8,n__take(X1,X2))) -> LENGTH(take(X1,X2))
 LENGTH(cons(x8,n__zeros)) -> LENGTH(zeros)
 LENGTH(cons(x8,X)) -> LENGTH(X)
->->-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros

Problem 1: 

Narrowing Processor:
-> Pairs:
 LENGTH(cons(x8,n__take(X1,X2))) -> LENGTH(take(X1,X2))
 LENGTH(cons(x8,n__zeros)) -> LENGTH(zeros)
 LENGTH(cons(x8,X)) -> LENGTH(X)
-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros
->Narrowed Pairs:
->->Original Pair:
 LENGTH(cons(x8,n__take(X1,X2))) -> LENGTH(take(X1,X2))
->-> Narrowed pairs:
 LENGTH(cons(x11,n__take(0,IL))) -> LENGTH(nil)
 LENGTH(cons(x11,n__take(s(M),cons(N,IL)))) -> LENGTH(cons(N,n__take(M,activate(IL))))
 LENGTH(cons(x11,n__take(X1,X2))) -> LENGTH(n__take(X1,X2))
->->Original Pair:
 LENGTH(cons(x8,n__zeros)) -> LENGTH(zeros)
->-> Narrowed pairs:
 LENGTH(cons(x12,n__zeros)) -> LENGTH(cons(0,n__zeros))
 LENGTH(cons(x12,n__zeros)) -> LENGTH(n__zeros)

Problem 1: 

Infinite Processor:
-> Pairs:
 LENGTH(cons(x8,X)) -> LENGTH(X)
 LENGTH(cons(x11,n__take(0,IL))) -> LENGTH(nil)
 LENGTH(cons(x11,n__take(s(M),cons(N,IL)))) -> LENGTH(cons(N,n__take(M,activate(IL))))
 LENGTH(cons(x11,n__take(X1,X2))) -> LENGTH(n__take(X1,X2))
 LENGTH(cons(x12,n__zeros)) -> LENGTH(cons(0,n__zeros))
 LENGTH(cons(x12,n__zeros)) -> LENGTH(n__zeros)
-> Rules:
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zeros) -> zeros
 activate(X) -> X
 and(tt,X) -> activate(X)
 length(cons(N,L)) -> s(length(activate(L)))
 length(nil) -> 0
 take(0,IL) -> nil
 take(s(M),cons(N,IL)) -> cons(N,n__take(M,activate(IL)))
 take(X1,X2) -> n__take(X1,X2)
 zeros -> cons(0,n__zeros)
 zeros -> n__zeros
-> Pairs in cycle:
 LENGTH(cons(x12,n__zeros)) -> LENGTH(cons(0,n__zeros))

The problem is infinite.