/export/starexec/sandbox2/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES 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: Matrix Interpretation Processor: dim=1 interpretation: [repItems](x0) = 2x0 + 4, [tail](x0) = 2x0 + 2, [pair](x0, x1) = 4x0 + x1, [zip](x0, x1) = 4x0 + x1, [nil] = 0, [take](x0, x1) = 2x0 + 2x1, [s](x0) = 2x0, [mark](x0) = x0, [cons](x0, x1) = 4x0 + x1, [incr](x0) = 2x0, [oddNs] = 0, [0] = 0, [active](x0) = x0, [pairNs] = 0 orientation: active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs()))) active(oddNs()) = 0 >= 0 = mark(incr(pairNs())) active(incr(cons(X,XS))) = 8X + 2XS >= 8X + 2XS = mark(cons(s(X),incr(XS))) active(take(0(),XS)) = 2XS >= 0 = mark(nil()) active(take(s(N),cons(X,XS))) = 4N + 8X + 2XS >= 2N + 4X + 2XS = mark(cons(X,take(N,XS))) active(zip(nil(),XS)) = XS >= 0 = mark(nil()) active(zip(X,nil())) = 4X >= 0 = mark(nil()) active(zip(cons(X,XS),cons(Y,YS))) = 16X + 4XS + 4Y + YS >= 16X + 4XS + 4Y + YS = mark(cons(pair(X,Y),zip(XS,YS))) active(tail(cons(X,XS))) = 8X + 2XS + 2 >= XS = mark(XS) active(repItems(nil())) = 4 >= 0 = mark(nil()) active(repItems(cons(X,XS))) = 8X + 2XS + 4 >= 8X + 2XS + 4 = mark(cons(X,cons(X,repItems(XS)))) mark(pairNs()) = 0 >= 0 = active(pairNs()) mark(cons(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(incr(X)) = 2X >= 2X = active(incr(mark(X))) mark(oddNs()) = 0 >= 0 = active(oddNs()) mark(s(X)) = 2X >= 2X = active(s(mark(X))) mark(take(X1,X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = active(take(mark(X1),mark(X2))) mark(nil()) = 0 >= 0 = active(nil()) mark(zip(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = active(zip(mark(X1),mark(X2))) mark(pair(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = active(pair(mark(X1),mark(X2))) mark(tail(X)) = 2X + 2 >= 2X + 2 = active(tail(mark(X))) mark(repItems(X)) = 2X + 4 >= 2X + 4 = active(repItems(mark(X))) cons(mark(X1),X2) = 4X1 + X2 >= 4X1 + X2 = cons(X1,X2) cons(X1,mark(X2)) = 4X1 + X2 >= 4X1 + X2 = cons(X1,X2) cons(active(X1),X2) = 4X1 + X2 >= 4X1 + X2 = cons(X1,X2) cons(X1,active(X2)) = 4X1 + X2 >= 4X1 + X2 = cons(X1,X2) incr(mark(X)) = 2X >= 2X = incr(X) incr(active(X)) = 2X >= 2X = incr(X) s(mark(X)) = 2X >= 2X = s(X) s(active(X)) = 2X >= 2X = s(X) take(mark(X1),X2) = 2X1 + 2X2 >= 2X1 + 2X2 = take(X1,X2) take(X1,mark(X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = take(X1,X2) take(active(X1),X2) = 2X1 + 2X2 >= 2X1 + 2X2 = take(X1,X2) take(X1,active(X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = take(X1,X2) zip(mark(X1),X2) = 4X1 + X2 >= 4X1 + X2 = zip(X1,X2) zip(X1,mark(X2)) = 4X1 + X2 >= 4X1 + X2 = zip(X1,X2) zip(active(X1),X2) = 4X1 + X2 >= 4X1 + X2 = zip(X1,X2) zip(X1,active(X2)) = 4X1 + X2 >= 4X1 + X2 = zip(X1,X2) pair(mark(X1),X2) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) pair(X1,mark(X2)) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) pair(active(X1),X2) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) pair(X1,active(X2)) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) tail(mark(X)) = 2X + 2 >= 2X + 2 = tail(X) tail(active(X)) = 2X + 2 >= 2X + 2 = tail(X) repItems(mark(X)) = 2X + 4 >= 2X + 4 = repItems(X) repItems(active(X)) = 2X + 4 >= 2X + 4 = repItems(X) 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(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) Matrix Interpretation Processor: dim=1 interpretation: [repItems](x0) = 3x0, [tail](x0) = x0 + 4, [pair](x0, x1) = 4x0 + x1, [zip](x0, x1) = 4x0 + 2x1, [nil] = 2, [take](x0, x1) = x0 + 2x1 + 4, [s](x0) = x0, [mark](x0) = x0, [cons](x0, x1) = x0 + x1, [incr](x0) = x0, [oddNs] = 0, [0] = 0, [active](x0) = x0, [pairNs] = 0 orientation: active(pairNs()) = 0 >= 0 = mark(cons(0(),incr(oddNs()))) active(oddNs()) = 0 >= 0 = mark(incr(pairNs())) active(incr(cons(X,XS))) = X + XS >= X + XS = mark(cons(s(X),incr(XS))) active(take(0(),XS)) = 2XS + 4 >= 2 = mark(nil()) active(take(s(N),cons(X,XS))) = N + 2X + 2XS + 4 >= N + X + 2XS + 4 = mark(cons(X,take(N,XS))) active(zip(nil(),XS)) = 2XS + 8 >= 2 = mark(nil()) active(zip(X,nil())) = 4X + 4 >= 2 = mark(nil()) active(zip(cons(X,XS),cons(Y,YS))) = 4X + 4XS + 2Y + 2YS >= 4X + 4XS + Y + 2YS = mark(cons(pair(X,Y),zip(XS,YS))) active(repItems(cons(X,XS))) = 3X + 3XS >= 2X + 3XS = mark(cons(X,cons(X,repItems(XS)))) mark(pairNs()) = 0 >= 0 = active(pairNs()) mark(cons(X1,X2)) = X1 + X2 >= X1 + X2 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(incr(X)) = X >= X = active(incr(mark(X))) mark(oddNs()) = 0 >= 0 = active(oddNs()) mark(s(X)) = X >= X = active(s(mark(X))) mark(take(X1,X2)) = X1 + 2X2 + 4 >= X1 + 2X2 + 4 = active(take(mark(X1),mark(X2))) mark(nil()) = 2 >= 2 = active(nil()) mark(zip(X1,X2)) = 4X1 + 2X2 >= 4X1 + 2X2 = active(zip(mark(X1),mark(X2))) mark(pair(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = active(pair(mark(X1),mark(X2))) mark(tail(X)) = X + 4 >= X + 4 = active(tail(mark(X))) mark(repItems(X)) = 3X >= 3X = active(repItems(mark(X))) cons(mark(X1),X2) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(X1,mark(X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(active(X1),X2) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(X1,active(X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2) incr(mark(X)) = X >= X = incr(X) incr(active(X)) = X >= X = incr(X) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) take(mark(X1),X2) = X1 + 2X2 + 4 >= X1 + 2X2 + 4 = take(X1,X2) take(X1,mark(X2)) = X1 + 2X2 + 4 >= X1 + 2X2 + 4 = take(X1,X2) take(active(X1),X2) = X1 + 2X2 + 4 >= X1 + 2X2 + 4 = take(X1,X2) take(X1,active(X2)) = X1 + 2X2 + 4 >= X1 + 2X2 + 4 = take(X1,X2) zip(mark(X1),X2) = 4X1 + 2X2 >= 4X1 + 2X2 = zip(X1,X2) zip(X1,mark(X2)) = 4X1 + 2X2 >= 4X1 + 2X2 = zip(X1,X2) zip(active(X1),X2) = 4X1 + 2X2 >= 4X1 + 2X2 = zip(X1,X2) zip(X1,active(X2)) = 4X1 + 2X2 >= 4X1 + 2X2 = zip(X1,X2) pair(mark(X1),X2) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) pair(X1,mark(X2)) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) pair(active(X1),X2) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) pair(X1,active(X2)) = 4X1 + X2 >= 4X1 + X2 = pair(X1,X2) tail(mark(X)) = X + 4 >= X + 4 = tail(X) tail(active(X)) = X + 4 >= X + 4 = tail(X) repItems(mark(X)) = 3X >= 3X = repItems(X) repItems(active(X)) = 3X >= 3X = repItems(X) 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(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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) Matrix Interpretation Processor: dim=3 interpretation: [1 0 1] [repItems](x0) = [0 0 0]x0 [1 0 1] , [1 0 0] [tail](x0) = [0 0 0]x0 [1 0 0] , [1 0 0] [1 0 0] [pair](x0, x1) = [1 0 0]x0 + [0 0 1]x1 [0 0 0] [0 0 0] , [1 0 1] [1 0 0] [0] [zip](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [0] [1 0 0] [0 0 1] [1], [0] [nil] = [0] [0], [1 0 1] [1 0 0] [0] [take](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [1] [0 0 0] [1 0 0] [0], [1 0 0] [0] [s](x0) = [0 0 1]x0 + [0] [0 0 1] [1], [1 0 0] [mark](x0) = [0 0 0]x0 [0 0 1] , [1 0 0] [1 0 0] [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 [1 0 0] [0 0 1] , [1 0 0] [incr](x0) = [0 0 0]x0 [1 0 0] , [0] [oddNs] = [0] [1], [0] [0] = [0] [0], [1 0 0] [active](x0) = [0 0 0]x0 [0 0 1] , [0] [pairNs] = [0] [0] orientation: [0] [0] active(pairNs()) = [0] >= [0] = mark(cons(0(),incr(oddNs()))) [0] [0] [0] [0] active(oddNs()) = [0] >= [0] = mark(incr(pairNs())) [1] [0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] active(incr(cons(X,XS))) = [0 0 0]X + [0 0 0]XS >= [0 0 0]X + [0 0 0]XS = mark(cons(s(X),incr(XS))) [1 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 1] [1 0 0] [1 0 0] [1] [1 0 1] [1 0 0] [1 0 0] active(take(s(N),cons(X,XS))) = [0 0 0]N + [0 0 0]X + [0 0 0]XS + [0] >= [0 0 0]N + [0 0 0]X + [0 0 0]XS = mark(cons(X,take(N,XS))) [0 0 0] [1 0 0] [1 0 0] [0] [0 0 0] [1 0 0] [1 0 0] [2 0 0] [1 0 1] [1 0 0] [1 0 0] [0] [1 0 0] [1 0 1] [1 0 0] [1 0 0] [0] active(zip(cons(X,XS),cons(Y,YS))) = [0 0 0]X + [0 0 0]XS + [0 0 0]Y + [0 0 0]YS + [0] >= [0 0 0]X + [0 0 0]XS + [0 0 0]Y + [0 0 0]YS + [0] = mark(cons(pair(X,Y),zip(XS,YS))) [1 0 0] [1 0 0] [1 0 0] [0 0 1] [1] [1 0 0] [1 0 0] [1 0 0] [0 0 1] [1] [2 0 0] [1 0 1] [2 0 0] [1 0 1] active(repItems(cons(X,XS))) = [0 0 0]X + [0 0 0]XS >= [0 0 0]X + [0 0 0]XS = mark(cons(X,cons(X,repItems(XS)))) [2 0 0] [1 0 1] [2 0 0] [1 0 1] [0] [0] mark(pairNs()) = [0] >= [0] = active(pairNs()) [0] [0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] mark(cons(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = active(cons(mark(X1),X2)) [1 0 0] [0 0 1] [1 0 0] [0 0 1] [0] [0] mark(0()) = [0] >= [0] = active(0()) [0] [0] [1 0 0] [1 0 0] mark(incr(X)) = [0 0 0]X >= [0 0 0]X = active(incr(mark(X))) [1 0 0] [1 0 0] [0] [0] mark(oddNs()) = [0] >= [0] = active(oddNs()) [1] [1] [1 0 0] [0] [1 0 0] [0] mark(s(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(s(mark(X))) [0 0 1] [1] [0 0 1] [1] [1 0 1] [1 0 0] [1 0 1] [1 0 0] mark(take(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = active(take(mark(X1),mark(X2))) [0 0 0] [1 0 0] [0 0 0] [1 0 0] [0] [0] mark(nil()) = [0] >= [0] = active(nil()) [0] [0] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] mark(zip(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 + [0] = active(zip(mark(X1),mark(X2))) [1 0 0] [0 0 1] [1] [1 0 0] [0 0 1] [1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] mark(pair(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = active(pair(mark(X1),mark(X2))) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] mark(tail(X)) = [0 0 0]X >= [0 0 0]X = active(tail(mark(X))) [1 0 0] [1 0 0] [1 0 1] [1 0 1] mark(repItems(X)) = [0 0 0]X >= [0 0 0]X = active(repItems(mark(X))) [1 0 1] [1 0 1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(mark(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [1 0 0] [0 0 1] [1 0 0] [0 0 1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(X1,mark(X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [1 0 0] [0 0 1] [1 0 0] [0 0 1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(active(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [1 0 0] [0 0 1] [1 0 0] [0 0 1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(X1,active(X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [1 0 0] [0 0 1] [1 0 0] [0 0 1] [1 0 0] [1 0 0] incr(mark(X)) = [0 0 0]X >= [0 0 0]X = incr(X) [1 0 0] [1 0 0] [1 0 0] [1 0 0] incr(active(X)) = [0 0 0]X >= [0 0 0]X = incr(X) [1 0 0] [1 0 0] [1 0 0] [0] [1 0 0] [0] s(mark(X)) = [0 0 1]X + [0] >= [0 0 1]X + [0] = s(X) [0 0 1] [1] [0 0 1] [1] [1 0 0] [0] [1 0 0] [0] s(active(X)) = [0 0 1]X + [0] >= [0 0 1]X + [0] = s(X) [0 0 1] [1] [0 0 1] [1] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] take(mark(X1),X2) = [0 0 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = take(X1,X2) [0 0 0] [1 0 0] [0] [0 0 0] [1 0 0] [0] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] take(X1,mark(X2)) = [0 0 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = take(X1,X2) [0 0 0] [1 0 0] [0] [0 0 0] [1 0 0] [0] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] take(active(X1),X2) = [0 0 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = take(X1,X2) [0 0 0] [1 0 0] [0] [0 0 0] [1 0 0] [0] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] take(X1,active(X2)) = [0 0 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = take(X1,X2) [0 0 0] [1 0 0] [0] [0 0 0] [1 0 0] [0] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] zip(mark(X1),X2) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 + [0] = zip(X1,X2) [1 0 0] [0 0 1] [1] [1 0 0] [0 0 1] [1] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] zip(X1,mark(X2)) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 + [0] = zip(X1,X2) [1 0 0] [0 0 1] [1] [1 0 0] [0 0 1] [1] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] zip(active(X1),X2) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 + [0] = zip(X1,X2) [1 0 0] [0 0 1] [1] [1 0 0] [0 0 1] [1] [1 0 1] [1 0 0] [0] [1 0 1] [1 0 0] [0] zip(X1,active(X2)) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 + [0] = zip(X1,X2) [1 0 0] [0 0 1] [1] [1 0 0] [0 0 1] [1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] pair(mark(X1),X2) = [1 0 0]X1 + [0 0 1]X2 >= [1 0 0]X1 + [0 0 1]X2 = pair(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] pair(X1,mark(X2)) = [1 0 0]X1 + [0 0 1]X2 >= [1 0 0]X1 + [0 0 1]X2 = pair(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] pair(active(X1),X2) = [1 0 0]X1 + [0 0 1]X2 >= [1 0 0]X1 + [0 0 1]X2 = pair(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] pair(X1,active(X2)) = [1 0 0]X1 + [0 0 1]X2 >= [1 0 0]X1 + [0 0 1]X2 = pair(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] tail(mark(X)) = [0 0 0]X >= [0 0 0]X = tail(X) [1 0 0] [1 0 0] [1 0 0] [1 0 0] tail(active(X)) = [0 0 0]X >= [0 0 0]X = tail(X) [1 0 0] [1 0 0] [1 0 1] [1 0 1] repItems(mark(X)) = [0 0 0]X >= [0 0 0]X = repItems(X) [1 0 1] [1 0 1] [1 0 1] [1 0 1] repItems(active(X)) = [0 0 0]X >= [0 0 0]X = repItems(X) [1 0 1] [1 0 1] 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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) Matrix Interpretation Processor: dim=2 interpretation: [2 0] [repItems](x0) = [0 0]x0, [2 0] [2] [tail](x0) = [0 0]x0 + [2], [2 0] [1 0] [0] [pair](x0, x1) = [1 0]x0 + [0 0]x1 + [1], [2 0] [1 0] [zip](x0, x1) = [0 0]x0 + [0 0]x1, [1] [nil] = [1], [2 0] [1 0] [0] [take](x0, x1) = [2 0]x0 + [2 0]x1 + [3], [1 0] [0] [s](x0) = [2 1]x0 + [2], [1 0] [0] [mark](x0) = [1 2]x0 + [1], [1 0] [1 2] [cons](x0, x1) = [0 0]x0 + [0 0]x1, [2 0] [incr](x0) = [0 0]x0, [0] [oddNs] = [0], [0] [0] = [2], [1 0] [0] [active](x0) = [1 1]x0 + [1], [0] [pairNs] = [0] orientation: [0] [0] active(pairNs()) = [1] >= [1] = mark(cons(0(),incr(oddNs()))) [0] [0] active(oddNs()) = [1] >= [1] = mark(incr(pairNs())) [2 0] [2 4] [0] [1 0] [2 0] [0] active(incr(cons(X,XS))) = [2 0]X + [2 4]XS + [1] >= [1 0]X + [2 0]XS + [1] = mark(cons(s(X),incr(XS))) [2 0] [2 4] [1 0] [1 2] [0] [2 0] [2 0] [1 0] [1 0] [0] active(zip(cons(X,XS),cons(Y,YS))) = [2 0]X + [2 4]XS + [1 0]Y + [1 2]YS + [1] >= [2 0]X + [2 0]XS + [1 0]Y + [1 0]YS + [1] = mark(cons(pair(X,Y),zip(XS,YS))) [2 0] [2 4] [0] [2 0] [2 0] [0] active(repItems(cons(X,XS))) = [2 0]X + [2 4]XS + [1] >= [2 0]X + [2 0]XS + [1] = mark(cons(X,cons(X,repItems(XS)))) [0] [0] mark(pairNs()) = [1] >= [1] = active(pairNs()) [1 0] [1 2] [0] [1 0] [1 2] [0] mark(cons(X1,X2)) = [1 0]X1 + [1 2]X2 + [1] >= [1 0]X1 + [1 2]X2 + [1] = active(cons(mark(X1),X2)) [0] [0] mark(0()) = [5] >= [3] = active(0()) [2 0] [0] [2 0] [0] mark(incr(X)) = [2 0]X + [1] >= [2 0]X + [1] = active(incr(mark(X))) [0] [0] mark(oddNs()) = [1] >= [1] = active(oddNs()) [1 0] [0] [1 0] [0] mark(s(X)) = [5 2]X + [5] >= [4 2]X + [4] = active(s(mark(X))) [2 0] [1 0] [0] [2 0] [1 0] [0] mark(take(X1,X2)) = [6 0]X1 + [5 0]X2 + [7] >= [4 0]X1 + [3 0]X2 + [4] = active(take(mark(X1),mark(X2))) [1] [1] mark(nil()) = [4] >= [3] = active(nil()) [2 0] [1 0] [0] [2 0] [1 0] [0] mark(zip(X1,X2)) = [2 0]X1 + [1 0]X2 + [1] >= [2 0]X1 + [1 0]X2 + [1] = active(zip(mark(X1),mark(X2))) [2 0] [1 0] [0] [2 0] [1 0] [0] mark(pair(X1,X2)) = [4 0]X1 + [1 0]X2 + [3] >= [3 0]X1 + [1 0]X2 + [2] = active(pair(mark(X1),mark(X2))) [2 0] [2] [2 0] [2] mark(tail(X)) = [2 0]X + [7] >= [2 0]X + [5] = active(tail(mark(X))) [2 0] [0] [2 0] [0] mark(repItems(X)) = [2 0]X + [1] >= [2 0]X + [1] = active(repItems(mark(X))) [1 0] [1 2] [1 0] [1 2] cons(mark(X1),X2) = [0 0]X1 + [0 0]X2 >= [0 0]X1 + [0 0]X2 = cons(X1,X2) [1 0] [3 4] [2] [1 0] [1 2] cons(X1,mark(X2)) = [0 0]X1 + [0 0]X2 + [0] >= [0 0]X1 + [0 0]X2 = cons(X1,X2) [1 0] [1 2] [1 0] [1 2] cons(active(X1),X2) = [0 0]X1 + [0 0]X2 >= [0 0]X1 + [0 0]X2 = cons(X1,X2) [1 0] [3 2] [2] [1 0] [1 2] cons(X1,active(X2)) = [0 0]X1 + [0 0]X2 + [0] >= [0 0]X1 + [0 0]X2 = cons(X1,X2) [2 0] [2 0] incr(mark(X)) = [0 0]X >= [0 0]X = incr(X) [2 0] [2 0] incr(active(X)) = [0 0]X >= [0 0]X = incr(X) [1 0] [0] [1 0] [0] s(mark(X)) = [3 2]X + [3] >= [2 1]X + [2] = s(X) [1 0] [0] [1 0] [0] s(active(X)) = [3 1]X + [3] >= [2 1]X + [2] = s(X) [2 0] [1 0] [0] [2 0] [1 0] [0] take(mark(X1),X2) = [2 0]X1 + [2 0]X2 + [3] >= [2 0]X1 + [2 0]X2 + [3] = take(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] take(X1,mark(X2)) = [2 0]X1 + [2 0]X2 + [3] >= [2 0]X1 + [2 0]X2 + [3] = take(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] take(active(X1),X2) = [2 0]X1 + [2 0]X2 + [3] >= [2 0]X1 + [2 0]X2 + [3] = take(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] take(X1,active(X2)) = [2 0]X1 + [2 0]X2 + [3] >= [2 0]X1 + [2 0]X2 + [3] = take(X1,X2) [2 0] [1 0] [2 0] [1 0] zip(mark(X1),X2) = [0 0]X1 + [0 0]X2 >= [0 0]X1 + [0 0]X2 = zip(X1,X2) [2 0] [1 0] [2 0] [1 0] zip(X1,mark(X2)) = [0 0]X1 + [0 0]X2 >= [0 0]X1 + [0 0]X2 = zip(X1,X2) [2 0] [1 0] [2 0] [1 0] zip(active(X1),X2) = [0 0]X1 + [0 0]X2 >= [0 0]X1 + [0 0]X2 = zip(X1,X2) [2 0] [1 0] [2 0] [1 0] zip(X1,active(X2)) = [0 0]X1 + [0 0]X2 >= [0 0]X1 + [0 0]X2 = zip(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] pair(mark(X1),X2) = [1 0]X1 + [0 0]X2 + [1] >= [1 0]X1 + [0 0]X2 + [1] = pair(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] pair(X1,mark(X2)) = [1 0]X1 + [0 0]X2 + [1] >= [1 0]X1 + [0 0]X2 + [1] = pair(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] pair(active(X1),X2) = [1 0]X1 + [0 0]X2 + [1] >= [1 0]X1 + [0 0]X2 + [1] = pair(X1,X2) [2 0] [1 0] [0] [2 0] [1 0] [0] pair(X1,active(X2)) = [1 0]X1 + [0 0]X2 + [1] >= [1 0]X1 + [0 0]X2 + [1] = pair(X1,X2) [2 0] [2] [2 0] [2] tail(mark(X)) = [0 0]X + [2] >= [0 0]X + [2] = tail(X) [2 0] [2] [2 0] [2] tail(active(X)) = [0 0]X + [2] >= [0 0]X + [2] = tail(X) [2 0] [2 0] repItems(mark(X)) = [0 0]X >= [0 0]X = repItems(X) [2 0] [2 0] repItems(active(X)) = [0 0]X >= [0 0]X = repItems(X) 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) 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#(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#(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#(active(X1),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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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#(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#(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#(active(X1),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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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#(active(X)) -> tail#(X) tail#(mark(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X) tail#(active(X)) -> tail#(X) -> tail#(active(X)) -> tail#(X) tail#(active(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X) take#(mark(X1),X2) -> take#(X1,X2) -> take#(X1,active(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,mark(X2)) -> take#(X1,X2) take#(mark(X1),X2) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) -> take#(X1,active(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,mark(X2)) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) -> take#(X1,active(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,mark(X2)) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) -> take#(X1,active(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,mark(X2)) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) repItems#(mark(X)) -> repItems#(X) -> repItems#(active(X)) -> repItems#(X) repItems#(mark(X)) -> repItems#(X) -> repItems#(mark(X)) -> repItems#(X) repItems#(active(X)) -> repItems#(X) -> repItems#(active(X)) -> repItems#(X) repItems#(active(X)) -> repItems#(X) -> repItems#(mark(X)) -> repItems#(X) pair#(mark(X1),X2) -> pair#(X1,X2) -> pair#(X1,active(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,mark(X2)) -> pair#(X1,X2) pair#(mark(X1),X2) -> pair#(X1,X2) -> pair#(mark(X1),X2) -> pair#(X1,X2) pair#(active(X1),X2) -> pair#(X1,X2) -> pair#(X1,active(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,mark(X2)) -> pair#(X1,X2) pair#(active(X1),X2) -> pair#(X1,X2) -> pair#(mark(X1),X2) -> pair#(X1,X2) pair#(X1,mark(X2)) -> pair#(X1,X2) -> pair#(X1,active(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,mark(X2)) -> pair#(X1,X2) pair#(X1,mark(X2)) -> pair#(X1,X2) -> pair#(mark(X1),X2) -> pair#(X1,X2) pair#(X1,active(X2)) -> pair#(X1,X2) -> pair#(X1,active(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,mark(X2)) -> pair#(X1,X2) pair#(X1,active(X2)) -> pair#(X1,X2) -> pair#(mark(X1),X2) -> pair#(X1,X2) zip#(mark(X1),X2) -> zip#(X1,X2) -> zip#(X1,active(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,mark(X2)) -> zip#(X1,X2) zip#(mark(X1),X2) -> zip#(X1,X2) -> zip#(mark(X1),X2) -> zip#(X1,X2) zip#(active(X1),X2) -> zip#(X1,X2) -> zip#(X1,active(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,mark(X2)) -> zip#(X1,X2) zip#(active(X1),X2) -> zip#(X1,X2) -> zip#(mark(X1),X2) -> zip#(X1,X2) zip#(X1,mark(X2)) -> zip#(X1,X2) -> zip#(X1,active(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,mark(X2)) -> zip#(X1,X2) zip#(X1,mark(X2)) -> zip#(X1,X2) -> zip#(mark(X1),X2) -> zip#(X1,X2) zip#(X1,active(X2)) -> zip#(X1,X2) -> zip#(X1,active(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,mark(X2)) -> zip#(X1,X2) zip#(X1,active(X2)) -> zip#(X1,X2) -> zip#(mark(X1),X2) -> zip#(X1,X2) s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X) s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X) s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X) mark#(repItems(X)) -> repItems#(mark(X)) -> repItems#(active(X)) -> repItems#(X) mark#(repItems(X)) -> repItems#(mark(X)) -> repItems#(mark(X)) -> repItems#(X) mark#(repItems(X)) -> mark#(X) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(repItems(X)) -> mark#(X) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(repItems(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X) mark#(repItems(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(repItems(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(repItems(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(repItems(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) mark#(repItems(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) mark#(repItems(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1) mark#(repItems(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2) mark#(repItems(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) mark#(repItems(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(repItems(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(repItems(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(repItems(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(repItems(X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(repItems(X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(repItems(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) mark#(repItems(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) mark#(repItems(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(repItems(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(repItems(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(repItems(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs()) mark#(repItems(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(repItems(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(repItems(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(repItems(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(repItems(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(repItems(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(repItems(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(repItems(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs()) mark#(repItems(X)) -> active#(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,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(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)) 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))) -> incr#(XS) mark#(repItems(X)) -> active#(repItems(mark(X))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(repItems(X)) -> active#(repItems(mark(X))) -> active#(oddNs()) -> incr#(pairNs()) mark#(repItems(X)) -> active#(repItems(mark(X))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(repItems(X)) -> active#(repItems(mark(X))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(repItems(X)) -> active#(repItems(mark(X))) -> active#(pairNs()) -> incr#(oddNs()) mark#(tail(X)) -> tail#(mark(X)) -> tail#(active(X)) -> tail#(X) mark#(tail(X)) -> tail#(mark(X)) -> tail#(mark(X)) -> tail#(X) mark#(tail(X)) -> mark#(X) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) mark#(tail(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) mark#(tail(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2) mark#(tail(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) mark#(tail(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(tail(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(tail(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(tail(X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(tail(X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(tail(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs()) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs()) mark#(tail(X)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) 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))) -> s#(X) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(oddNs()) -> incr#(pairNs()) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(pairNs()) -> incr#(oddNs()) mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) -> pair#(X1,active(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,mark(X2)) -> pair#(X1,X2) mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) -> pair#(mark(X1),X2) -> pair#(X1,X2) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> tail#(mark(X)) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(nil()) -> active#(nil()) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> mark#(X2) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> active#(s(mark(X))) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X)) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(oddNs()) -> active#(oddNs()) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> incr#(mark(X)) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0()) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(pairNs()) -> active#(pairNs()) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> tail#(mark(X)) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(oddNs()) -> active#(oddNs()) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> incr#(mark(X)) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(pairNs()) -> active#(pairNs()) mark#(pair(X1,X2)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(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))) -> cons#(s(X),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))) -> incr#(XS) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) -> active#(oddNs()) -> incr#(pairNs()) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) -> active#(pairNs()) -> incr#(oddNs()) mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) -> zip#(X1,active(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,mark(X2)) -> zip#(X1,X2) mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) -> zip#(mark(X1),X2) -> zip#(X1,X2) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> tail#(mark(X)) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(nil()) -> active#(nil()) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> mark#(X2) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> active#(s(mark(X))) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X)) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(oddNs()) -> active#(oddNs()) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> incr#(mark(X)) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0()) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(pairNs()) -> active#(pairNs()) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> tail#(mark(X)) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(oddNs()) -> active#(oddNs()) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> incr#(mark(X)) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(pairNs()) -> active#(pairNs()) mark#(zip(X1,X2)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(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))) -> cons#(s(X),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))) -> incr#(XS) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) -> active#(oddNs()) -> incr#(pairNs()) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) -> active#(pairNs()) -> incr#(oddNs()) mark#(nil()) -> active#(nil()) -> active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) mark#(nil()) -> active#(nil()) -> active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) mark#(nil()) -> active#(nil()) -> active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) mark#(nil()) -> active#(nil()) -> active#(repItems(cons(X,XS))) -> repItems#(XS) mark#(nil()) -> active#(nil()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) mark#(nil()) -> active#(nil()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) mark#(nil()) -> active#(nil()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) mark#(nil()) -> active#(nil()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,XS))) -> s#(X) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(nil()) -> active#(nil()) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(nil()) -> active#(nil()) -> active#(oddNs()) -> incr#(pairNs()) mark#(nil()) -> active#(nil()) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(nil()) -> active#(nil()) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(nil()) -> active#(nil()) -> active#(pairNs()) -> incr#(oddNs()) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) -> take#(X1,active(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,mark(X2)) -> take#(X1,X2) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) -> take#(mark(X1),X2) -> take#(X1,X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> tail#(mark(X)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(tail(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X2) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(nil()) -> active#(nil()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> active#(s(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X2) -> mark#(oddNs()) -> active#(oddNs()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> incr#(mark(X)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(incr(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(pairNs()) -> active#(pairNs()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> tail#(mark(X)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(oddNs()) -> active#(oddNs()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> incr#(mark(X)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(take(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(pairNs()) -> active#(pairNs()) mark#(take(X1,X2)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(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))) -> cons#(s(X),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))) -> incr#(XS) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(oddNs()) -> incr#(pairNs()) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(pairNs()) -> incr#(oddNs()) mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X) mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X) mark#(s(X)) -> mark#(X) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) mark#(s(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) mark#(s(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs()) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs()) mark#(s(X)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) 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))) -> s#(X) mark#(s(X)) -> active#(s(mark(X))) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(s(X)) -> active#(s(mark(X))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(s(X)) -> active#(s(mark(X))) -> active#(oddNs()) -> incr#(pairNs()) mark#(s(X)) -> active#(s(mark(X))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(s(X)) -> active#(s(mark(X))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(s(X)) -> active#(s(mark(X))) -> active#(pairNs()) -> incr#(oddNs()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> tail#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(pair(X1,X2)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(oddNs()) -> active#(oddNs()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> incr#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(pairNs()) -> active#(pairNs()) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) -> cons#(active(X1),X2) -> cons#(X1,X2) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) mark#(cons(X1,X2)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) 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))) -> s#(X) 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#(oddNs()) -> mark#(incr(pairNs())) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(oddNs()) -> incr#(pairNs()) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(pairNs()) -> incr#(oddNs()) mark#(incr(X)) -> mark#(X) -> mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(repItems(X)) -> repItems#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(repItems(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) mark#(incr(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) mark#(incr(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(X) -> mark#(pair(X1,X2)) -> mark#(X2) mark#(incr(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) mark#(incr(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) mark#(incr(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(X) -> mark#(zip(X1,X2)) -> mark#(X2) mark#(incr(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(incr(X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(incr(X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(incr(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(oddNs()) -> active#(oddNs()) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(X) -> mark#(pairNs()) -> active#(pairNs()) mark#(incr(X)) -> incr#(mark(X)) -> incr#(active(X)) -> incr#(X) mark#(incr(X)) -> incr#(mark(X)) -> incr#(mark(X)) -> incr#(X) mark#(incr(X)) -> active#(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))) -> cons#(X,cons(X,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))) -> repItems#(XS) 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#(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))) -> pair#(X,Y) 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#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) 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))) -> s#(X) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(oddNs()) -> incr#(pairNs()) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(pairNs()) -> incr#(oddNs()) mark#(oddNs()) -> active#(oddNs()) -> active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) mark#(oddNs()) -> active#(oddNs()) -> active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) mark#(oddNs()) -> active#(oddNs()) -> active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) mark#(oddNs()) -> active#(oddNs()) -> active#(repItems(cons(X,XS))) -> repItems#(XS) mark#(oddNs()) -> active#(oddNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) mark#(oddNs()) -> active#(oddNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) mark#(oddNs()) -> active#(oddNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) mark#(oddNs()) -> active#(oddNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS) mark#(oddNs()) -> active#(oddNs()) -> active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(oddNs()) -> active#(oddNs()) -> active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) mark#(oddNs()) -> active#(oddNs()) -> active#(incr(cons(X,XS))) -> s#(X) mark#(oddNs()) -> active#(oddNs()) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(oddNs()) -> active#(oddNs()) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(oddNs()) -> active#(oddNs()) -> active#(oddNs()) -> incr#(pairNs()) mark#(oddNs()) -> active#(oddNs()) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(oddNs()) -> active#(oddNs()) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(oddNs()) -> active#(oddNs()) -> active#(pairNs()) -> incr#(oddNs()) mark#(0()) -> active#(0()) -> active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) mark#(0()) -> active#(0()) -> active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) mark#(0()) -> active#(0()) -> active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) mark#(0()) -> active#(0()) -> active#(repItems(cons(X,XS))) -> repItems#(XS) mark#(0()) -> active#(0()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) mark#(0()) -> active#(0()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) mark#(0()) -> active#(0()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) mark#(0()) -> active#(0()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS) mark#(0()) -> active#(0()) -> active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(0()) -> active#(0()) -> active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) mark#(0()) -> active#(0()) -> active#(incr(cons(X,XS))) -> s#(X) mark#(0()) -> active#(0()) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(0()) -> active#(0()) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(0()) -> active#(0()) -> active#(oddNs()) -> incr#(pairNs()) mark#(0()) -> active#(0()) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(0()) -> active#(0()) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(0()) -> active#(0()) -> active#(pairNs()) -> incr#(oddNs()) mark#(pairNs()) -> active#(pairNs()) -> active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) mark#(pairNs()) -> active#(pairNs()) -> active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS))) mark#(pairNs()) -> active#(pairNs()) -> active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS)) mark#(pairNs()) -> active#(pairNs()) -> active#(repItems(cons(X,XS))) -> repItems#(XS) mark#(pairNs()) -> active#(pairNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) mark#(pairNs()) -> active#(pairNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS)) mark#(pairNs()) -> active#(pairNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y) mark#(pairNs()) -> active#(pairNs()) -> active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS) mark#(pairNs()) -> active#(pairNs()) -> active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(pairNs()) -> active#(pairNs()) -> active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS)) mark#(pairNs()) -> active#(pairNs()) -> active#(incr(cons(X,XS))) -> s#(X) mark#(pairNs()) -> active#(pairNs()) -> active#(incr(cons(X,XS))) -> incr#(XS) mark#(pairNs()) -> active#(pairNs()) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(pairNs()) -> active#(pairNs()) -> active#(oddNs()) -> incr#(pairNs()) mark#(pairNs()) -> active#(pairNs()) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(pairNs()) -> active#(pairNs()) -> active#(pairNs()) -> cons#(0(),incr(oddNs())) mark#(pairNs()) -> active#(pairNs()) -> active#(pairNs()) -> incr#(oddNs()) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(active(X1),X2) -> cons#(X1,X2) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(mark(X1),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#(mark(X1),X2) -> cons#(X1,X2) incr#(mark(X)) -> incr#(X) -> incr#(active(X)) -> incr#(X) incr#(mark(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X) incr#(active(X)) -> incr#(X) -> incr#(active(X)) -> incr#(X) incr#(active(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X) active#(repItems(cons(X,XS))) -> repItems#(XS) -> repItems#(active(X)) -> repItems#(X) active#(repItems(cons(X,XS))) -> repItems#(XS) -> repItems#(mark(X)) -> repItems#(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))) -> 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)) -> 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#(tail(X)) -> tail#(mark(X)) 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#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) 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)) -> mark#(X1) 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#(zip(X1,X2)) -> active#(zip(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)) 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)) -> mark#(X2) active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) -> mark#(nil()) -> active#(nil()) 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#(take(X1,X2)) -> take#(mark(X1),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)) -> mark#(X2) 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#(s(X)) -> s#(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#(oddNs()) -> active#(oddNs()) 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#(incr(X)) -> incr#(mark(X)) 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#(0()) -> active#(0()) 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#(cons(X1,X2)) -> cons#(mark(X1),X2) 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#(pairNs()) -> active#(pairNs()) 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#(mark(X1),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#(mark(X1),X2) -> cons#(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))) -> pair#(X,Y) -> pair#(active(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#(mark(X1),X2) -> pair#(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))) -> zip#(XS,YS) -> zip#(active(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#(mark(X1),X2) -> zip#(X1,X2) 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))) -> 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)) -> 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#(tail(X)) -> tail#(mark(X)) 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#(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)) -> 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) 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#(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)) -> 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)) -> mark#(X1) 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#(nil()) -> active#(nil()) 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#(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)) -> mark#(X1) 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#(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)) -> s#(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#(oddNs()) -> active#(oddNs()) 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#(incr(X)) -> incr#(mark(X)) 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#(0()) -> active#(0()) 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#(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)) -> mark#(X1) active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) -> mark#(pairNs()) -> active#(pairNs()) 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#(mark(X1),X2) -> cons#(X1,X2) active#(incr(cons(X,XS))) -> s#(X) -> s#(active(X)) -> s#(X) active#(incr(cons(X,XS))) -> s#(X) -> s#(mark(X)) -> s#(X) active#(incr(cons(X,XS))) -> mark#(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)) -> repItems#(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#(tail(X)) -> active#(tail(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)) -> mark#(X) 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#(pair(X1,X2)) -> pair#(mark(X1),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)) -> 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#(zip(X1,X2)) -> zip#(mark(X1),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)) -> mark#(X2) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) -> mark#(nil()) -> active#(nil()) 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#(take(X1,X2)) -> take#(mark(X1),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)) -> mark#(X2) 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#(s(X)) -> s#(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#(oddNs()) -> active#(oddNs()) 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#(incr(X)) -> incr#(mark(X)) 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#(0()) -> active#(0()) 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#(cons(X1,X2)) -> cons#(mark(X1),X2) 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#(pairNs()) -> active#(pairNs()) 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#(mark(X1),X2) -> cons#(X1,X2) active#(incr(cons(X,XS))) -> incr#(XS) -> incr#(active(X)) -> incr#(X) active#(incr(cons(X,XS))) -> incr#(XS) -> incr#(mark(X)) -> incr#(X) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(repItems(X)) -> active#(repItems(mark(X))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(repItems(X)) -> repItems#(mark(X)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(repItems(X)) -> mark#(X) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(tail(X)) -> active#(tail(mark(X))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(tail(X)) -> tail#(mark(X)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(tail(X)) -> mark#(X) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(pair(X1,X2)) -> mark#(X1) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(pair(X1,X2)) -> mark#(X2) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(zip(X1,X2)) -> mark#(X1) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(zip(X1,X2)) -> mark#(X2) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(nil()) -> active#(nil()) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(take(X1,X2)) -> mark#(X1) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(take(X1,X2)) -> mark#(X2) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(s(X)) -> active#(s(mark(X))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(s(X)) -> s#(mark(X)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(s(X)) -> mark#(X) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(oddNs()) -> active#(oddNs()) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(incr(X)) -> active#(incr(mark(X))) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(incr(X)) -> incr#(mark(X)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(incr(X)) -> mark#(X) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(0()) -> active#(0()) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(cons(X1,X2)) -> mark#(X1) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(pairNs()) -> active#(pairNs()) active#(oddNs()) -> incr#(pairNs()) -> incr#(active(X)) -> incr#(X) active#(oddNs()) -> incr#(pairNs()) -> incr#(mark(X)) -> incr#(X) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(repItems(X)) -> active#(repItems(mark(X))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(repItems(X)) -> repItems#(mark(X)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(repItems(X)) -> mark#(X) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(tail(X)) -> active#(tail(mark(X))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(tail(X)) -> tail#(mark(X)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(tail(X)) -> mark#(X) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(pair(X1,X2)) -> mark#(X1) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(pair(X1,X2)) -> mark#(X2) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(zip(X1,X2)) -> mark#(X1) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(zip(X1,X2)) -> mark#(X2) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(nil()) -> active#(nil()) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(take(X1,X2)) -> mark#(X1) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(take(X1,X2)) -> mark#(X2) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(s(X)) -> active#(s(mark(X))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(s(X)) -> s#(mark(X)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(s(X)) -> mark#(X) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(oddNs()) -> active#(oddNs()) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(incr(X)) -> active#(incr(mark(X))) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(incr(X)) -> incr#(mark(X)) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(incr(X)) -> mark#(X) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(0()) -> active#(0()) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) 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)) -> mark#(X1) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) -> mark#(pairNs()) -> active#(pairNs()) active#(pairNs()) -> cons#(0(),incr(oddNs())) -> cons#(active(X1),X2) -> cons#(X1,X2) active#(pairNs()) -> cons#(0(),incr(oddNs())) -> cons#(mark(X1),X2) -> cons#(X1,X2) active#(pairNs()) -> incr#(oddNs()) -> incr#(active(X)) -> incr#(X) active#(pairNs()) -> incr#(oddNs()) -> incr#(mark(X)) -> incr#(X) SCC Processor: #sccs: 9 #rules: 50 #arcs: 818/4900 DPs: mark#(repItems(X)) -> mark#(X) mark#(pairNs()) -> active#(pairNs()) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(oddNs()) -> mark#(incr(pairNs())) mark#(0()) -> active#(0()) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) mark#(oddNs()) -> active#(oddNs()) active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) mark#(s(X)) -> 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)) -> 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)) -> active#(zip(mark(X1),mark(X2))) mark#(pair(X1,X2)) -> mark#(X2) mark#(pair(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> active#(tail(mark(X))) mark#(repItems(X)) -> active#(repItems(mark(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) EDG Processor: DPs: mark#(repItems(X)) -> mark#(X) mark#(pairNs()) -> active#(pairNs()) active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(oddNs()) -> mark#(incr(pairNs())) mark#(0()) -> active#(0()) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) mark#(oddNs()) -> active#(oddNs()) active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) mark#(s(X)) -> 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)) -> 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)) -> active#(zip(mark(X1),mark(X2))) mark#(pair(X1,X2)) -> mark#(X2) mark#(pair(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2))) mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> active#(tail(mark(X))) mark#(repItems(X)) -> active#(repItems(mark(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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: 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(pair(mark(X1),mark(X2))) mark#(repItems(X)) -> mark#(X) -> mark#(tail(X)) -> 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)) -> active#(repItems(mark(X))) mark#(repItems(X)) -> active#(repItems(mark(X))) -> active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS)))) 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(pair(mark(X1),mark(X2))) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> 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)) -> active#(repItems(mark(X))) 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(pair(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(X))) 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(zip(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(zip(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> 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#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS))) 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(repItems(X)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(pair(mark(X1),mark(X2))) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> 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)) -> active#(repItems(mark(X))) 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(tail(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(repItems(X)) -> active#(repItems(mark(X))) 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> active#(pair(mark(X1),mark(X2))) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> 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)) -> active#(repItems(mark(X))) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(oddNs()) -> active#(oddNs()) -> active#(oddNs()) -> mark#(incr(pairNs())) mark#(pairNs()) -> active#(pairNs()) -> active#(pairNs()) -> mark#(cons(0(),incr(oddNs()))) 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)) -> 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)) -> mark#(X1) 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#(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)) -> active#(cons(mark(X1),X2)) active#(oddNs()) -> mark#(incr(pairNs())) -> mark#(incr(X)) -> 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)) -> active#(cons(mark(X1),X2)) SCC Processor: #sccs: 1 #rules: 21 #arcs: 268/784 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#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) mark#(oddNs()) -> active#(oddNs()) active#(oddNs()) -> mark#(incr(pairNs())) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(X) 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Bounds Processor: bound: 0 enrichment: top-dp automaton: final states: {138} transitions: oddNs0() -> 139* mark{#,0}(142) -> 138* mark{#,0}(141) -> 138* incr0(139) -> 140* 00() -> 141* cons0(141,140) -> 142* problem: 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#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) mark#(oddNs()) -> active#(oddNs()) active#(oddNs()) -> mark#(incr(pairNs())) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(X) mark#(pairNs()) -> active#(pairNs()) 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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: 1 #rules: 19 #arcs: 187/400 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#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) mark#(pair(X1,X2)) -> mark#(X1) mark#(pair(X1,X2)) -> mark#(X2) 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)) -> mark#(X1) mark#(zip(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) mark#(oddNs()) -> active#(oddNs()) active#(oddNs()) -> mark#(incr(pairNs())) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) KBO Processor: argument filtering: pi(pairNs) = [] pi(active) = 0 pi(0) = [] pi(oddNs) = [] pi(incr) = 0 pi(cons) = 0 pi(mark) = 0 pi(s) = 0 pi(take) = [0,1] pi(nil) = [] pi(zip) = [0,1] pi(pair) = [0,1] pi(tail) = 0 pi(repItems) = 0 pi(active#) = 0 pi(mark#) = 0 usable rules: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) weight function: w0 = 1 w(tail) = w(pair) = w(zip) = w(nil) = w(take) = w(cons) = w( oddNs) = w(0) = w(pairNs) = 1 w(mark#) = w(active#) = w(repItems) = w(s) = w(mark) = w( incr) = w(active) = 0 precedence: oddNs > pairNs > zip > mark# ~ active# ~ repItems ~ tail ~ pair ~ nil ~ take ~ s ~ mark ~ cons ~ incr ~ 0 ~ active problem: 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#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) mark#(s(X)) -> mark#(X) mark#(oddNs()) -> active#(oddNs()) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Restore Modifier: 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#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2))) mark#(s(X)) -> mark#(X) mark#(oddNs()) -> active#(oddNs()) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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: 1 #rules: 9 #arcs: 174/121 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#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) KBO Processor: argument filtering: pi(pairNs) = [] pi(active) = 0 pi(0) = [] pi(oddNs) = [] pi(incr) = 0 pi(cons) = 0 pi(mark) = 0 pi(s) = 0 pi(take) = [1] pi(nil) = [] pi(zip) = [0,1] pi(pair) = 1 pi(tail) = [0] pi(repItems) = 0 pi(active#) = 0 pi(mark#) = 0 usable rules: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) weight function: w0 = 1 w(active#) = w(tail) = w(pair) = w(nil) = w(take) = w( s) = w(cons) = w(oddNs) = w(0) = w(pairNs) = 1 w(mark#) = w(repItems) = w(zip) = w(mark) = w(incr) = w( active) = 0 precedence: oddNs > pairNs > mark# ~ active# ~ repItems ~ tail ~ pair ~ zip ~ nil ~ take ~ s ~ mark ~ cons ~ incr ~ 0 ~ active problem: 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#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Restore Modifier: 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#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) KBO Processor: argument filtering: pi(pairNs) = [] pi(active) = 0 pi(0) = [] pi(oddNs) = [] pi(incr) = 0 pi(cons) = 0 pi(mark) = 0 pi(s) = 0 pi(take) = 1 pi(nil) = [] pi(zip) = 1 pi(pair) = 1 pi(tail) = [] pi(repItems) = [0] pi(active#) = 0 pi(mark#) = 0 usable rules: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) weight function: w0 = 1 w(repItems) = w(tail) = w(pair) = w(zip) = w(nil) = w( oddNs) = w(0) = w(active) = w(pairNs) = 1 w(mark#) = w(active#) = w(take) = w(s) = w(mark) = w( cons) = w(incr) = 0 precedence: oddNs > pairNs > mark# ~ active# ~ repItems ~ tail ~ pair ~ zip ~ nil ~ take ~ s ~ mark ~ cons ~ incr ~ 0 ~ active problem: DPs: mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Restore Modifier: DPs: mark#(repItems(X)) -> active#(repItems(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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: 1 #rules: 5 #arcs: 39/36 DPs: mark#(s(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS))) mark#(cons(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) LPO Processor: argument filtering: pi(pairNs) = [] pi(active) = 0 pi(0) = [] pi(oddNs) = [] pi(incr) = [0] pi(cons) = 0 pi(mark) = 0 pi(s) = [0] pi(take) = 1 pi(nil) = [] pi(zip) = 1 pi(pair) = 1 pi(tail) = [] pi(repItems) = 0 pi(active#) = 0 pi(mark#) = 0 usable rules: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) precedence: oddNs > incr ~ pairNs > mark# ~ active# ~ repItems ~ tail ~ pair ~ zip ~ nil ~ take ~ s ~ mark ~ cons ~ 0 ~ active problem: DPs: mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Restore Modifier: DPs: mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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: 1 #rules: 1 #arcs: 14/4 DPs: mark#(cons(X1,X2)) -> mark#(X1) TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Size-Change Termination Processor: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) The DP: mark#(cons(X1,X2)) -> mark#(X1) has the edges: 0 > 0 Qed DPs: cons#(mark(X1),X2) -> cons#(X1,X2) cons#(active(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(cons#) = 0 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed DPs: incr#(mark(X)) -> incr#(X) incr#(active(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(incr#) = 0 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(s#) = 0 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed DPs: 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) 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(zip#) = 0 problem: DPs: zip#(X1,mark(X2)) -> zip#(X1,X2) zip#(X1,active(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(zip#) = 1 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed DPs: 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) 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(pair#) = 0 problem: DPs: pair#(X1,mark(X2)) -> pair#(X1,X2) pair#(X1,active(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(pair#) = 1 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(repItems#) = 0 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed DPs: 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) 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(take#) = 0 problem: DPs: take#(X1,mark(X2)) -> take#(X1,X2) take#(X1,active(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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(take#) = 1 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed 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(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Subterm Criterion Processor: simple projection: pi(tail#) = 0 problem: DPs: TRS: active(pairNs()) -> mark(cons(0(),incr(oddNs()))) active(oddNs()) -> mark(incr(pairNs())) active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS))) active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS))) 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(active(X1),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) Qed