KILLED
proof of /export/starexec/sandbox/benchmark/theBenchmark.trs
# AProVE Commit ID: c69e44bd14796315568835c1ffa2502984884775 mhark 20210624 unpublished


The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).

(0) CpxRelTRS
(1) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
(2) TRS for Loop Detection
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CpxRelTRS
    (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) typed CpxTrs
    (9) OrderProof [LOWER BOUND(ID), 7 ms]
    (10) typed CpxTrs
(11) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(12) CpxWeightedTrs
    (13) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (14) CpxTypedWeightedTrs
    (15) CompletionProof [UPPER BOUND(ID), 0 ms]
    (16) CpxTypedWeightedCompleteTrs
        (17) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (18) CpxTypedWeightedCompleteTrs
        (19) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 8 ms]
        (20) CpxRNTS
        (21) InliningProof [UPPER BOUND(ID), 0 ms]
        (22) CpxRNTS
        (23) SimplificationProof [BOTH BOUNDS(ID, ID), 1 ms]
        (24) CpxRNTS
    (25) CompletionProof [UPPER BOUND(ID), 0 ms]
    (26) CpxTypedWeightedCompleteTrs
        (27) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (28) CpxRNTS
(29) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(30) CdtProblem
    (31) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (32) CdtProblem
    (33) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (34) CdtProblem
    (35) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (36) CdtProblem
    (37) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (38) CdtProblem
    (39) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (40) CdtProblem
    (41) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 8 ms]
    (42) CdtProblem
    (43) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (44) CdtProblem
    (45) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (46) CdtProblem
    (47) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (48) CdtProblem
    (49) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (50) CdtProblem
    (51) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (52) CdtProblem
    (53) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (54) CdtProblem
    (55) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (56) CdtProblem
    (57) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (58) CdtProblem
    (59) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (60) CdtProblem
    (61) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) CdtProblem
    (63) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (64) CdtProblem
    (65) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (68) CdtProblem
    (69) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 4 ms]
    (80) CdtProblem
    (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtRewritingProof [BOTH BOUNDS(ID, ID), 7 ms]
    (94) CdtProblem
    (95) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtRewritingProof [BOTH BOUNDS(ID, ID), 14 ms]
    (120) CdtProblem
    (121) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 60 ms]
    (122) CdtProblem
    (123) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 4 ms]
    (124) CdtProblem
    (125) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 102 ms]
    (128) CdtProblem
    (129) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 24 ms]
    (132) CdtProblem
    (133) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtRewritingProof [BOTH BOUNDS(ID, ID), 25 ms]
    (138) CdtProblem
    (139) CdtRewritingProof [BOTH BOUNDS(ID, ID), 44 ms]
    (140) CdtProblem
    (141) CdtRewritingProof [BOTH BOUNDS(ID, ID), 9 ms]
    (142) CdtProblem


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

(0)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(1) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID))
Transformed a relative TRS into a decreasing-loop problem.
----------------------------------------

(2)
Obligation:
Analyzing the following TRS for decreasing loops:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(3) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(4)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(5) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(6)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0')))), FROM(s(s(0'))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   primes -> sieve(from(s(s(0'))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(7) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(8)
Obligation:
Innermost TRS:
Rules:
PRIMES -> c(SIEVE(from(s(s(0')))), FROM(s(s(0'))))
FROM(z0) -> c1(FROM(s(z0)))
HEAD(cons(z0, z1)) -> c2
TAIL(cons(z0, z1)) -> c3
IF(true, z0, z1) -> c4
IF(false, z0, z1) -> c5
FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
primes -> sieve(from(s(s(0'))))
from(z0) -> cons(z0, from(s(z0)))
head(cons(z0, z1)) -> z0
tail(cons(z0, z1)) -> z1
if(true, z0, z1) -> z0
if(false, z0, z1) -> z1
filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Types:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0':s:cons -> c8
from :: 0':s:cons -> 0':s:cons
s :: 0':s:cons -> 0':s:cons
0' :: 0':s:cons
FROM :: 0':s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0':s:cons -> c2
cons :: 0':s:cons -> 0':s:cons -> 0':s:cons
c2 :: c2
TAIL :: 0':s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0':s:cons -> 0':s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0':s:cons -> 0':s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0':s:cons -> 0':s:cons -> true:false:divides
filter :: 0':s:cons -> 0':s:cons -> 0':s:cons
sieve :: 0':s:cons -> 0':s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0':s:cons
head :: 0':s:cons -> 0':s:cons
tail :: 0':s:cons -> 0':s:cons
if :: true:false:divides -> 0':s:cons -> 0':s:cons -> 0':s:cons
hole_c1_9 :: c
hole_c82_9 :: c8
hole_c13_9 :: c1
hole_0':s:cons4_9 :: 0':s:cons
hole_c25_9 :: c2
hole_c36_9 :: c3
hole_c4:c57_9 :: c4:c5
hole_true:false:divides8_9 :: true:false:divides
hole_c6:c79_9 :: c6:c7
gen_c810_9 :: Nat -> c8
gen_c111_9 :: Nat -> c1
gen_0':s:cons12_9 :: Nat -> 0':s:cons
gen_c6:c713_9 :: Nat -> c6:c7

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

(9) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
SIEVE, from, FROM, FILTER, filter, sieve

They will be analysed ascendingly in the following order:
SIEVE = FILTER
sieve < SIEVE
filter < FILTER
sieve < FILTER
filter = sieve

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

(10)
Obligation:
Innermost TRS:
Rules:
PRIMES -> c(SIEVE(from(s(s(0')))), FROM(s(s(0'))))
FROM(z0) -> c1(FROM(s(z0)))
HEAD(cons(z0, z1)) -> c2
TAIL(cons(z0, z1)) -> c3
IF(true, z0, z1) -> c4
IF(false, z0, z1) -> c5
FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
primes -> sieve(from(s(s(0'))))
from(z0) -> cons(z0, from(s(z0)))
head(cons(z0, z1)) -> z0
tail(cons(z0, z1)) -> z1
if(true, z0, z1) -> z0
if(false, z0, z1) -> z1
filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Types:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0':s:cons -> c8
from :: 0':s:cons -> 0':s:cons
s :: 0':s:cons -> 0':s:cons
0' :: 0':s:cons
FROM :: 0':s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0':s:cons -> c2
cons :: 0':s:cons -> 0':s:cons -> 0':s:cons
c2 :: c2
TAIL :: 0':s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0':s:cons -> 0':s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0':s:cons -> 0':s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0':s:cons -> 0':s:cons -> true:false:divides
filter :: 0':s:cons -> 0':s:cons -> 0':s:cons
sieve :: 0':s:cons -> 0':s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0':s:cons
head :: 0':s:cons -> 0':s:cons
tail :: 0':s:cons -> 0':s:cons
if :: true:false:divides -> 0':s:cons -> 0':s:cons -> 0':s:cons
hole_c1_9 :: c
hole_c82_9 :: c8
hole_c13_9 :: c1
hole_0':s:cons4_9 :: 0':s:cons
hole_c25_9 :: c2
hole_c36_9 :: c3
hole_c4:c57_9 :: c4:c5
hole_true:false:divides8_9 :: true:false:divides
hole_c6:c79_9 :: c6:c7
gen_c810_9 :: Nat -> c8
gen_c111_9 :: Nat -> c1
gen_0':s:cons12_9 :: Nat -> 0':s:cons
gen_c6:c713_9 :: Nat -> c6:c7


Generator Equations:
gen_c810_9(0) <=> hole_c82_9
gen_c810_9(+(x, 1)) <=> c8(hole_c6:c79_9, gen_c810_9(x))
gen_c111_9(0) <=> hole_c13_9
gen_c111_9(+(x, 1)) <=> c1(gen_c111_9(x))
gen_0':s:cons12_9(0) <=> 0'
gen_0':s:cons12_9(+(x, 1)) <=> s(gen_0':s:cons12_9(x))
gen_c6:c713_9(0) <=> hole_c6:c79_9
gen_c6:c713_9(+(x, 1)) <=> c6(c4, gen_c6:c713_9(x))


The following defined symbols remain to be analysed:
from, SIEVE, FROM, FILTER, filter, sieve

They will be analysed ascendingly in the following order:
SIEVE = FILTER
sieve < SIEVE
filter < FILTER
sieve < FILTER
filter = sieve

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

(11) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(12)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0)))) [1]
   FROM(z0) -> c1(FROM(s(z0))) [1]
   HEAD(cons(z0, z1)) -> c2 [1]
   TAIL(cons(z0, z1)) -> c3 [1]
   IF(true, z0, z1) -> c4 [1]
   IF(false, z0, z1) -> c5 [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   primes -> sieve(from(s(s(0)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   head(cons(z0, z1)) -> z0 [0]
   tail(cons(z0, z1)) -> z1 [0]
   if(true, z0, z1) -> z0 [0]
   if(false, z0, z1) -> z1 [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(13) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(14)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0)))) [1]
   FROM(z0) -> c1(FROM(s(z0))) [1]
   HEAD(cons(z0, z1)) -> c2 [1]
   TAIL(cons(z0, z1)) -> c3 [1]
   IF(true, z0, z1) -> c4 [1]
   IF(false, z0, z1) -> c5 [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   primes -> sieve(from(s(s(0)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   head(cons(z0, z1)) -> z0 [0]
   tail(cons(z0, z1)) -> z1 [0]
   if(true, z0, z1) -> z0 [0]
   if(false, z0, z1) -> z1 [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]

The TRS has the following type information:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0:s:cons -> c8
from :: 0:s:cons -> 0:s:cons
s :: 0:s:cons -> 0:s:cons
0 :: 0:s:cons
FROM :: 0:s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0:s:cons -> c2
cons :: 0:s:cons -> 0:s:cons -> 0:s:cons
c2 :: c2
TAIL :: 0:s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0:s:cons -> 0:s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0:s:cons -> 0:s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0:s:cons -> 0:s:cons -> true:false:divides
filter :: 0:s:cons -> 0:s:cons -> 0:s:cons
sieve :: 0:s:cons -> 0:s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0:s:cons
head :: 0:s:cons -> 0:s:cons
tail :: 0:s:cons -> 0:s:cons
if :: true:false:divides -> 0:s:cons -> 0:s:cons -> 0:s:cons

Rewrite Strategy: INNERMOST
----------------------------------------

(15) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   PRIMES
   FROM_1
   HEAD_1
   TAIL_1
   IF_3
   FILTER_2
   SIEVE_1

(c) The following functions are completely defined:

   primes
   from_1
   head_1
   tail_1
   if_3
   filter_2
   sieve_1

Due to the following rules being added:

   primes -> 0 [0]
   from(v0) -> 0 [0]
   head(v0) -> 0 [0]
   tail(v0) -> 0 [0]
   if(v0, v1, v2) -> 0 [0]
   filter(v0, v1) -> 0 [0]
   sieve(v0) -> 0 [0]

And the following fresh constants:    const, const1, const2, const3

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

(16)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0)))) [1]
   FROM(z0) -> c1(FROM(s(z0))) [1]
   HEAD(cons(z0, z1)) -> c2 [1]
   TAIL(cons(z0, z1)) -> c3 [1]
   IF(true, z0, z1) -> c4 [1]
   IF(false, z0, z1) -> c5 [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   primes -> sieve(from(s(s(0)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   head(cons(z0, z1)) -> z0 [0]
   tail(cons(z0, z1)) -> z1 [0]
   if(true, z0, z1) -> z0 [0]
   if(false, z0, z1) -> z1 [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]
   primes -> 0 [0]
   from(v0) -> 0 [0]
   head(v0) -> 0 [0]
   tail(v0) -> 0 [0]
   if(v0, v1, v2) -> 0 [0]
   filter(v0, v1) -> 0 [0]
   sieve(v0) -> 0 [0]

The TRS has the following type information:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0:s:cons -> c8
from :: 0:s:cons -> 0:s:cons
s :: 0:s:cons -> 0:s:cons
0 :: 0:s:cons
FROM :: 0:s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0:s:cons -> c2
cons :: 0:s:cons -> 0:s:cons -> 0:s:cons
c2 :: c2
TAIL :: 0:s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0:s:cons -> 0:s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0:s:cons -> 0:s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0:s:cons -> 0:s:cons -> true:false:divides
filter :: 0:s:cons -> 0:s:cons -> 0:s:cons
sieve :: 0:s:cons -> 0:s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0:s:cons
head :: 0:s:cons -> 0:s:cons
tail :: 0:s:cons -> 0:s:cons
if :: true:false:divides -> 0:s:cons -> 0:s:cons -> 0:s:cons
const :: c
const1 :: c8
const2 :: c1
const3 :: c6:c7

Rewrite Strategy: INNERMOST
----------------------------------------

(17) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(18)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(cons(s(s(0)), from(s(s(s(0)))))), FROM(s(s(0)))) [1]
   PRIMES -> c(SIEVE(0), FROM(s(s(0)))) [1]
   FROM(z0) -> c1(FROM(s(z0))) [1]
   HEAD(cons(z0, z1)) -> c2 [1]
   TAIL(cons(z0, z1)) -> c3 [1]
   IF(true, z0, z1) -> c4 [1]
   IF(false, z0, z1) -> c5 [1]
   FILTER(s(s(z0)), cons(cons(z0', z1''), cons(z1', z2'))) -> c6(IF(divides(s(s(z0)), cons(z0', z1'')), if(divides(s(s(z0)), z1'), filter(s(s(z0)), z2'), cons(z1', filter(z0, sieve(z1')))), cons(cons(z0', z1''), filter(z0, cons(z0', filter(z0', sieve(z1'')))))), FILTER(s(s(z0)), cons(z1', z2'))) [1]
   FILTER(s(s(z0)), cons(z1, cons(z1', z2'))) -> c6(IF(divides(s(s(z0)), z1), if(divides(s(s(z0)), z1'), filter(s(s(z0)), z2'), cons(z1', filter(z0, sieve(z1')))), cons(z1, filter(z0, 0))), FILTER(s(s(z0)), cons(z1', z2'))) [1]
   FILTER(s(s(z0)), cons(cons(z0'', z11), z2)) -> c6(IF(divides(s(s(z0)), cons(z0'', z11)), 0, cons(cons(z0'', z11), filter(z0, cons(z0'', filter(z0'', sieve(z11)))))), FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), 0, cons(z1, filter(z0, 0))), FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(cons(z01, z13), cons(z12, z2''))) -> c7(IF(divides(s(s(z0)), cons(z01, z13)), if(divides(s(s(z0)), z12), filter(s(s(z0)), z2''), cons(z12, filter(z0, sieve(z12)))), cons(cons(z01, z13), filter(z0, cons(z01, filter(z01, sieve(z13)))))), FILTER(z0, cons(z01, filter(z01, sieve(z13)))), SIEVE(cons(z01, z13))) [1]
   FILTER(s(s(z0)), cons(cons(z01, z13), cons(z12, z2''))) -> c7(IF(divides(s(s(z0)), cons(z01, z13)), if(divides(s(s(z0)), z12), filter(s(s(z0)), z2''), cons(z12, filter(z0, sieve(z12)))), cons(cons(z01, z13), filter(z0, cons(z01, filter(z01, sieve(z13)))))), FILTER(z0, 0), SIEVE(cons(z01, z13))) [1]
   FILTER(s(s(z0)), cons(cons(z03, z15), cons(z12, z2''))) -> c7(IF(divides(s(s(z0)), cons(z03, z15)), if(divides(s(s(z0)), z12), filter(s(s(z0)), z2''), cons(z12, filter(z0, sieve(z12)))), cons(cons(z03, z15), filter(z0, 0))), FILTER(z0, cons(z03, filter(z03, sieve(z15)))), SIEVE(cons(z03, z15))) [1]
   FILTER(s(s(z0)), cons(z1, cons(z12, z2''))) -> c7(IF(divides(s(s(z0)), z1), if(divides(s(s(z0)), z12), filter(s(s(z0)), z2''), cons(z12, filter(z0, sieve(z12)))), cons(z1, filter(z0, 0))), FILTER(z0, 0), SIEVE(z1)) [1]
   FILTER(s(s(z0)), cons(cons(z02, z14), z2)) -> c7(IF(divides(s(s(z0)), cons(z02, z14)), 0, cons(cons(z02, z14), filter(z0, cons(z02, filter(z02, sieve(z14)))))), FILTER(z0, cons(z02, filter(z02, sieve(z14)))), SIEVE(cons(z02, z14))) [1]
   FILTER(s(s(z0)), cons(cons(z02, z14), z2)) -> c7(IF(divides(s(s(z0)), cons(z02, z14)), 0, cons(cons(z02, z14), filter(z0, cons(z02, filter(z02, sieve(z14)))))), FILTER(z0, 0), SIEVE(cons(z02, z14))) [1]
   FILTER(s(s(z0)), cons(cons(z04, z16), z2)) -> c7(IF(divides(s(s(z0)), cons(z04, z16)), 0, cons(cons(z04, z16), filter(z0, 0))), FILTER(z0, cons(z04, filter(z04, sieve(z16)))), SIEVE(cons(z04, z16))) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), 0, cons(z1, filter(z0, 0))), FILTER(z0, 0), SIEVE(z1)) [1]
   SIEVE(cons(z0, cons(z05, z17))) -> c8(FILTER(z0, cons(z05, filter(z05, sieve(z17)))), SIEVE(cons(z05, z17))) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, 0), SIEVE(z1)) [1]
   primes -> sieve(cons(s(s(0)), from(s(s(s(0)))))) [0]
   primes -> sieve(0) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   head(cons(z0, z1)) -> z0 [0]
   tail(cons(z0, z1)) -> z1 [0]
   if(true, z0, z1) -> z0 [0]
   if(false, z0, z1) -> z1 [0]
   filter(s(s(z0)), cons(cons(z06, z19), cons(z18, z21))) -> if(divides(s(s(z0)), cons(z06, z19)), if(divides(s(s(z0)), z18), filter(s(s(z0)), z21), cons(z18, filter(z0, sieve(z18)))), cons(cons(z06, z19), filter(z0, cons(z06, filter(z06, sieve(z19)))))) [0]
   filter(s(s(z0)), cons(z1, cons(z18, z21))) -> if(divides(s(s(z0)), z1), if(divides(s(s(z0)), z18), filter(s(s(z0)), z21), cons(z18, filter(z0, sieve(z18)))), cons(z1, filter(z0, 0))) [0]
   filter(s(s(z0)), cons(cons(z07, z110), z2)) -> if(divides(s(s(z0)), cons(z07, z110)), 0, cons(cons(z07, z110), filter(z0, cons(z07, filter(z07, sieve(z110)))))) [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), 0, cons(z1, filter(z0, 0))) [0]
   sieve(cons(z0, cons(z08, z111))) -> cons(z0, filter(z0, cons(z08, filter(z08, sieve(z111))))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, 0)) [0]
   primes -> 0 [0]
   from(v0) -> 0 [0]
   head(v0) -> 0 [0]
   tail(v0) -> 0 [0]
   if(v0, v1, v2) -> 0 [0]
   filter(v0, v1) -> 0 [0]
   sieve(v0) -> 0 [0]

The TRS has the following type information:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0:s:cons -> c8
from :: 0:s:cons -> 0:s:cons
s :: 0:s:cons -> 0:s:cons
0 :: 0:s:cons
FROM :: 0:s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0:s:cons -> c2
cons :: 0:s:cons -> 0:s:cons -> 0:s:cons
c2 :: c2
TAIL :: 0:s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0:s:cons -> 0:s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0:s:cons -> 0:s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0:s:cons -> 0:s:cons -> true:false:divides
filter :: 0:s:cons -> 0:s:cons -> 0:s:cons
sieve :: 0:s:cons -> 0:s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0:s:cons
head :: 0:s:cons -> 0:s:cons
tail :: 0:s:cons -> 0:s:cons
if :: true:false:divides -> 0:s:cons -> 0:s:cons -> 0:s:cons
const :: c
const1 :: c8
const2 :: c1
const3 :: c6:c7

Rewrite Strategy: INNERMOST
----------------------------------------

(19) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   c2 => 0
   c3 => 0
   true => 1
   c4 => 0
   false => 0
   c5 => 1
   const => 0
   const1 => 0
   const2 => 0
   const3 => 0

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

(20)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, if(1 + (1 + (1 + z0)) + z1', filter(1 + (1 + z0), z2'), 1 + z1' + filter(z0, sieve(z1'))), 1 + z1 + filter(z0, 0)) + FILTER(1 + (1 + z0), 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z0 >= 0, z = 1 + (1 + z0)
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, 0, 1 + z1 + filter(z0, 0)) + FILTER(1 + (1 + z0), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z0' + z1''), if(1 + (1 + (1 + z0)) + z1', filter(1 + (1 + z0), z2'), 1 + z1' + filter(z0, sieve(z1'))), 1 + (1 + z0' + z1'') + filter(z0, 1 + z0' + filter(z0', sieve(z1'')))) + FILTER(1 + (1 + z0), 1 + z1' + z2') :|: z0' >= 0, z1' >= 0, z2' >= 0, z0 >= 0, z' = 1 + (1 + z0' + z1'') + (1 + z1' + z2'), z = 1 + (1 + z0), z1'' >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z0'' + z11), 0, 1 + (1 + z0'' + z11) + filter(z0, 1 + z0'' + filter(z0'', sieve(z11)))) + FILTER(1 + (1 + z0), z2) :|: z11 >= 0, z0 >= 0, z0'' >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z0'' + z11) + z2, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + z1 + filter(z0, 0)) + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + (1 + z12 + z2''), z0 >= 0, z12 >= 0, z = 1 + (1 + z0), z2'' >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, 0, 1 + z1 + filter(z0, 0)) + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z01 + z13), if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + (1 + z01 + z13) + filter(z0, 1 + z01 + filter(z01, sieve(z13)))) + FILTER(z0, 0) + SIEVE(1 + z01 + z13) :|: z01 >= 0, z0 >= 0, z12 >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z01 + z13) + (1 + z12 + z2''), z2'' >= 0, z13 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z01 + z13), if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + (1 + z01 + z13) + filter(z0, 1 + z01 + filter(z01, sieve(z13)))) + FILTER(z0, 1 + z01 + filter(z01, sieve(z13))) + SIEVE(1 + z01 + z13) :|: z01 >= 0, z0 >= 0, z12 >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z01 + z13) + (1 + z12 + z2''), z2'' >= 0, z13 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z02 + z14), 0, 1 + (1 + z02 + z14) + filter(z0, 1 + z02 + filter(z02, sieve(z14)))) + FILTER(z0, 0) + SIEVE(1 + z02 + z14) :|: z02 >= 0, z' = 1 + (1 + z02 + z14) + z2, z0 >= 0, z = 1 + (1 + z0), z14 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z02 + z14), 0, 1 + (1 + z02 + z14) + filter(z0, 1 + z02 + filter(z02, sieve(z14)))) + FILTER(z0, 1 + z02 + filter(z02, sieve(z14))) + SIEVE(1 + z02 + z14) :|: z02 >= 0, z' = 1 + (1 + z02 + z14) + z2, z0 >= 0, z = 1 + (1 + z0), z14 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z03 + z15), if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + (1 + z03 + z15) + filter(z0, 0)) + FILTER(z0, 1 + z03 + filter(z03, sieve(z15))) + SIEVE(1 + z03 + z15) :|: z15 >= 0, z0 >= 0, z12 >= 0, z03 >= 0, z = 1 + (1 + z0), z2'' >= 0, z' = 1 + (1 + z03 + z15) + (1 + z12 + z2'')
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z04 + z16), 0, 1 + (1 + z04 + z16) + filter(z0, 0)) + FILTER(z0, 1 + z04 + filter(z04, sieve(z16))) + SIEVE(1 + z04 + z16) :|: z04 >= 0, z0 >= 0, z16 >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z04 + z16) + z2, z2 >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z0) :|: z = z0, z0 >= 0
   HEAD(z) -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   IF(z, z', z'') -{ 1 }-> 1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   IF(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   PRIMES -{ 1 }-> 1 + SIEVE(0) + FROM(1 + (1 + 0)) :|: 
   PRIMES -{ 1 }-> 1 + SIEVE(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) + FROM(1 + (1 + 0)) :|: 
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 1 + z05 + filter(z05, sieve(z17))) + SIEVE(1 + z05 + z17) :|: z = 1 + z0 + (1 + z05 + z17), z17 >= 0, z0 >= 0, z05 >= 0
   TAIL(z) -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + z1, if(1 + (1 + (1 + z0)) + z18, filter(1 + (1 + z0), z21), 1 + z18 + filter(z0, sieve(z18))), 1 + z1 + filter(z0, 0)) :|: z21 >= 0, z18 >= 0, z1 >= 0, z' = 1 + z1 + (1 + z18 + z21), z0 >= 0, z = 1 + (1 + z0)
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + z1, 0, 1 + z1 + filter(z0, 0)) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + (1 + z06 + z19), if(1 + (1 + (1 + z0)) + z18, filter(1 + (1 + z0), z21), 1 + z18 + filter(z0, sieve(z18))), 1 + (1 + z06 + z19) + filter(z0, 1 + z06 + filter(z06, sieve(z19)))) :|: z21 >= 0, z18 >= 0, z19 >= 0, z' = 1 + (1 + z06 + z19) + (1 + z18 + z21), z06 >= 0, z0 >= 0, z = 1 + (1 + z0)
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + (1 + z07 + z110), 0, 1 + (1 + z07 + z110) + filter(z0, 1 + z07 + filter(z07, sieve(z110)))) :|: z110 >= 0, z07 >= 0, z0 >= 0, z' = 1 + (1 + z07 + z110) + z2, z = 1 + (1 + z0), z2 >= 0
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   from(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   from(z) -{ 0 }-> 1 + z0 + from(1 + z0) :|: z = z0, z0 >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   if(z, z', z'') -{ 0 }-> z0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   primes -{ 0 }-> sieve(0) :|: 
   primes -{ 0 }-> sieve(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   primes -{ 0 }-> 0 :|: 
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 1 + z08 + filter(z08, sieve(z111))) :|: z08 >= 0, z = 1 + z0 + (1 + z08 + z111), z0 >= 0, z111 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


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

(21) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   IF(z, z', z'') -{ 1 }-> 1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   IF(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> z0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0

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

(22)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, if(1 + (1 + (1 + z0)) + z1', filter(1 + (1 + z0), z2'), 1 + z1' + filter(z0, sieve(z1'))), 1 + z1 + filter(z0, 0)) + FILTER(1 + (1 + z0), 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z0 >= 0, z = 1 + (1 + z0)
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, 0, 1 + z1 + filter(z0, 0)) + FILTER(1 + (1 + z0), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z0' + z1''), if(1 + (1 + (1 + z0)) + z1', filter(1 + (1 + z0), z2'), 1 + z1' + filter(z0, sieve(z1'))), 1 + (1 + z0' + z1'') + filter(z0, 1 + z0' + filter(z0', sieve(z1'')))) + FILTER(1 + (1 + z0), 1 + z1' + z2') :|: z0' >= 0, z1' >= 0, z2' >= 0, z0 >= 0, z' = 1 + (1 + z0' + z1'') + (1 + z1' + z2'), z = 1 + (1 + z0), z1'' >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z0'' + z11), 0, 1 + (1 + z0'' + z11) + filter(z0, 1 + z0'' + filter(z0'', sieve(z11)))) + FILTER(1 + (1 + z0), z2) :|: z11 >= 0, z0 >= 0, z0'' >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z0'' + z11) + z2, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + z1 + filter(z0, 0)) + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + (1 + z12 + z2''), z0 >= 0, z12 >= 0, z = 1 + (1 + z0), z2'' >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, 0, 1 + z1 + filter(z0, 0)) + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z01 + z13), if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + (1 + z01 + z13) + filter(z0, 1 + z01 + filter(z01, sieve(z13)))) + FILTER(z0, 0) + SIEVE(1 + z01 + z13) :|: z01 >= 0, z0 >= 0, z12 >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z01 + z13) + (1 + z12 + z2''), z2'' >= 0, z13 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z01 + z13), if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + (1 + z01 + z13) + filter(z0, 1 + z01 + filter(z01, sieve(z13)))) + FILTER(z0, 1 + z01 + filter(z01, sieve(z13))) + SIEVE(1 + z01 + z13) :|: z01 >= 0, z0 >= 0, z12 >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z01 + z13) + (1 + z12 + z2''), z2'' >= 0, z13 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z02 + z14), 0, 1 + (1 + z02 + z14) + filter(z0, 1 + z02 + filter(z02, sieve(z14)))) + FILTER(z0, 0) + SIEVE(1 + z02 + z14) :|: z02 >= 0, z' = 1 + (1 + z02 + z14) + z2, z0 >= 0, z = 1 + (1 + z0), z14 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z02 + z14), 0, 1 + (1 + z02 + z14) + filter(z0, 1 + z02 + filter(z02, sieve(z14)))) + FILTER(z0, 1 + z02 + filter(z02, sieve(z14))) + SIEVE(1 + z02 + z14) :|: z02 >= 0, z' = 1 + (1 + z02 + z14) + z2, z0 >= 0, z = 1 + (1 + z0), z14 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z03 + z15), if(1 + (1 + (1 + z0)) + z12, filter(1 + (1 + z0), z2''), 1 + z12 + filter(z0, sieve(z12))), 1 + (1 + z03 + z15) + filter(z0, 0)) + FILTER(z0, 1 + z03 + filter(z03, sieve(z15))) + SIEVE(1 + z03 + z15) :|: z15 >= 0, z0 >= 0, z12 >= 0, z03 >= 0, z = 1 + (1 + z0), z2'' >= 0, z' = 1 + (1 + z03 + z15) + (1 + z12 + z2'')
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + (1 + z04 + z16), 0, 1 + (1 + z04 + z16) + filter(z0, 0)) + FILTER(z0, 1 + z04 + filter(z04, sieve(z16))) + SIEVE(1 + z04 + z16) :|: z04 >= 0, z0 >= 0, z16 >= 0, z = 1 + (1 + z0), z' = 1 + (1 + z04 + z16) + z2, z2 >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z0) :|: z = z0, z0 >= 0
   HEAD(z) -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   IF(z, z', z'') -{ 1 }-> 1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   IF(z, z', z'') -{ 1 }-> 0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   PRIMES -{ 1 }-> 1 + SIEVE(0) + FROM(1 + (1 + 0)) :|: 
   PRIMES -{ 1 }-> 1 + SIEVE(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) + FROM(1 + (1 + 0)) :|: 
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 1 + z05 + filter(z05, sieve(z17))) + SIEVE(1 + z05 + z17) :|: z = 1 + z0 + (1 + z05 + z17), z17 >= 0, z0 >= 0, z05 >= 0
   TAIL(z) -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + z1, if(1 + (1 + (1 + z0)) + z18, filter(1 + (1 + z0), z21), 1 + z18 + filter(z0, sieve(z18))), 1 + z1 + filter(z0, 0)) :|: z21 >= 0, z18 >= 0, z1 >= 0, z' = 1 + z1 + (1 + z18 + z21), z0 >= 0, z = 1 + (1 + z0)
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + z1, 0, 1 + z1 + filter(z0, 0)) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + (1 + z06 + z19), if(1 + (1 + (1 + z0)) + z18, filter(1 + (1 + z0), z21), 1 + z18 + filter(z0, sieve(z18))), 1 + (1 + z06 + z19) + filter(z0, 1 + z06 + filter(z06, sieve(z19)))) :|: z21 >= 0, z18 >= 0, z19 >= 0, z' = 1 + (1 + z06 + z19) + (1 + z18 + z21), z06 >= 0, z0 >= 0, z = 1 + (1 + z0)
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + (1 + z07 + z110), 0, 1 + (1 + z07 + z110) + filter(z0, 1 + z07 + filter(z07, sieve(z110)))) :|: z110 >= 0, z07 >= 0, z0 >= 0, z' = 1 + (1 + z07 + z110) + z2, z = 1 + (1 + z0), z2 >= 0
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   from(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   from(z) -{ 0 }-> 1 + z0 + from(1 + z0) :|: z = z0, z0 >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   if(z, z', z'') -{ 0 }-> z0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   primes -{ 0 }-> sieve(0) :|: 
   primes -{ 0 }-> sieve(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   primes -{ 0 }-> 0 :|: 
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 1 + z08 + filter(z08, sieve(z111))) :|: z08 >= 0, z = 1 + z0 + (1 + z08 + z111), z0 >= 0, z111 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


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

(23) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(24)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + z1, if(1 + (1 + (1 + (z - 2))) + z1', filter(1 + (1 + (z - 2)), z2'), 1 + z1' + filter(z - 2, sieve(z1'))), 1 + z1 + filter(z - 2, 0)) + FILTER(1 + (1 + (z - 2)), 1 + z1' + z2') :|: z1 >= 0, z1' >= 0, z2' >= 0, z' = 1 + z1 + (1 + z1' + z2'), z - 2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + z1, 0, 1 + z1 + filter(z - 2, 0)) + FILTER(1 + (1 + (z - 2)), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 2 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z0' + z1''), if(1 + (1 + (1 + (z - 2))) + z1', filter(1 + (1 + (z - 2)), z2'), 1 + z1' + filter(z - 2, sieve(z1'))), 1 + (1 + z0' + z1'') + filter(z - 2, 1 + z0' + filter(z0', sieve(z1'')))) + FILTER(1 + (1 + (z - 2)), 1 + z1' + z2') :|: z0' >= 0, z1' >= 0, z2' >= 0, z - 2 >= 0, z' = 1 + (1 + z0' + z1'') + (1 + z1' + z2'), z1'' >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z0'' + z11), 0, 1 + (1 + z0'' + z11) + filter(z - 2, 1 + z0'' + filter(z0'', sieve(z11)))) + FILTER(1 + (1 + (z - 2)), z2) :|: z11 >= 0, z - 2 >= 0, z0'' >= 0, z' = 1 + (1 + z0'' + z11) + z2, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + z1, if(1 + (1 + (1 + (z - 2))) + z12, filter(1 + (1 + (z - 2)), z2''), 1 + z12 + filter(z - 2, sieve(z12))), 1 + z1 + filter(z - 2, 0)) + FILTER(z - 2, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + (1 + z12 + z2''), z - 2 >= 0, z12 >= 0, z2'' >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + z1, 0, 1 + z1 + filter(z - 2, 0)) + FILTER(z - 2, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z - 2 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z01 + z13), if(1 + (1 + (1 + (z - 2))) + z12, filter(1 + (1 + (z - 2)), z2''), 1 + z12 + filter(z - 2, sieve(z12))), 1 + (1 + z01 + z13) + filter(z - 2, 1 + z01 + filter(z01, sieve(z13)))) + FILTER(z - 2, 0) + SIEVE(1 + z01 + z13) :|: z01 >= 0, z - 2 >= 0, z12 >= 0, z' = 1 + (1 + z01 + z13) + (1 + z12 + z2''), z2'' >= 0, z13 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z01 + z13), if(1 + (1 + (1 + (z - 2))) + z12, filter(1 + (1 + (z - 2)), z2''), 1 + z12 + filter(z - 2, sieve(z12))), 1 + (1 + z01 + z13) + filter(z - 2, 1 + z01 + filter(z01, sieve(z13)))) + FILTER(z - 2, 1 + z01 + filter(z01, sieve(z13))) + SIEVE(1 + z01 + z13) :|: z01 >= 0, z - 2 >= 0, z12 >= 0, z' = 1 + (1 + z01 + z13) + (1 + z12 + z2''), z2'' >= 0, z13 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z02 + z14), 0, 1 + (1 + z02 + z14) + filter(z - 2, 1 + z02 + filter(z02, sieve(z14)))) + FILTER(z - 2, 0) + SIEVE(1 + z02 + z14) :|: z02 >= 0, z' = 1 + (1 + z02 + z14) + z2, z - 2 >= 0, z14 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z02 + z14), 0, 1 + (1 + z02 + z14) + filter(z - 2, 1 + z02 + filter(z02, sieve(z14)))) + FILTER(z - 2, 1 + z02 + filter(z02, sieve(z14))) + SIEVE(1 + z02 + z14) :|: z02 >= 0, z' = 1 + (1 + z02 + z14) + z2, z - 2 >= 0, z14 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z03 + z15), if(1 + (1 + (1 + (z - 2))) + z12, filter(1 + (1 + (z - 2)), z2''), 1 + z12 + filter(z - 2, sieve(z12))), 1 + (1 + z03 + z15) + filter(z - 2, 0)) + FILTER(z - 2, 1 + z03 + filter(z03, sieve(z15))) + SIEVE(1 + z03 + z15) :|: z15 >= 0, z - 2 >= 0, z12 >= 0, z03 >= 0, z2'' >= 0, z' = 1 + (1 + z03 + z15) + (1 + z12 + z2'')
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + (z - 2))) + (1 + z04 + z16), 0, 1 + (1 + z04 + z16) + filter(z - 2, 0)) + FILTER(z - 2, 1 + z04 + filter(z04, sieve(z16))) + SIEVE(1 + z04 + z16) :|: z04 >= 0, z - 2 >= 0, z16 >= 0, z' = 1 + (1 + z04 + z16) + z2, z2 >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z) :|: z >= 0
   HEAD(z) -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   IF(z, z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' >= 0, z = 0
   IF(z, z', z'') -{ 1 }-> 0 :|: z'' >= 0, z = 1, z' >= 0
   PRIMES -{ 1 }-> 1 + SIEVE(0) + FROM(1 + (1 + 0)) :|: 
   PRIMES -{ 1 }-> 1 + SIEVE(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) + FROM(1 + (1 + 0)) :|: 
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 1 + z05 + filter(z05, sieve(z17))) + SIEVE(1 + z05 + z17) :|: z = 1 + z0 + (1 + z05 + z17), z17 >= 0, z0 >= 0, z05 >= 0
   TAIL(z) -{ 1 }-> 0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + (z - 2))) + z1, if(1 + (1 + (1 + (z - 2))) + z18, filter(1 + (1 + (z - 2)), z21), 1 + z18 + filter(z - 2, sieve(z18))), 1 + z1 + filter(z - 2, 0)) :|: z21 >= 0, z18 >= 0, z1 >= 0, z' = 1 + z1 + (1 + z18 + z21), z - 2 >= 0
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + (z - 2))) + z1, 0, 1 + z1 + filter(z - 2, 0)) :|: z1 >= 0, z' = 1 + z1 + z2, z - 2 >= 0, z2 >= 0
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + (z - 2))) + (1 + z06 + z19), if(1 + (1 + (1 + (z - 2))) + z18, filter(1 + (1 + (z - 2)), z21), 1 + z18 + filter(z - 2, sieve(z18))), 1 + (1 + z06 + z19) + filter(z - 2, 1 + z06 + filter(z06, sieve(z19)))) :|: z21 >= 0, z18 >= 0, z19 >= 0, z' = 1 + (1 + z06 + z19) + (1 + z18 + z21), z06 >= 0, z - 2 >= 0
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + (z - 2))) + (1 + z07 + z110), 0, 1 + (1 + z07 + z110) + filter(z - 2, 1 + z07 + filter(z07, sieve(z110)))) :|: z110 >= 0, z07 >= 0, z - 2 >= 0, z' = 1 + (1 + z07 + z110) + z2, z2 >= 0
   filter(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   from(z) -{ 0 }-> 0 :|: z >= 0
   from(z) -{ 0 }-> 1 + z + from(1 + z) :|: z >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 0 :|: z >= 0
   if(z, z', z'') -{ 0 }-> z' :|: z'' >= 0, z = 1, z' >= 0
   if(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   primes -{ 0 }-> sieve(0) :|: 
   primes -{ 0 }-> sieve(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   primes -{ 0 }-> 0 :|: 
   sieve(z) -{ 0 }-> 0 :|: z >= 0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 1 + z08 + filter(z08, sieve(z111))) :|: z08 >= 0, z = 1 + z0 + (1 + z08 + z111), z0 >= 0, z111 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z >= 0


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

(25) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   primes -> null_primes [0]
   from(v0) -> null_from [0]
   head(v0) -> null_head [0]
   tail(v0) -> null_tail [0]
   if(v0, v1, v2) -> null_if [0]
   filter(v0, v1) -> null_filter [0]
   sieve(v0) -> null_sieve [0]
   HEAD(v0) -> null_HEAD [0]
   TAIL(v0) -> null_TAIL [0]
   IF(v0, v1, v2) -> null_IF [0]
   FILTER(v0, v1) -> null_FILTER [0]
   SIEVE(v0) -> null_SIEVE [0]

And the following fresh constants:    null_primes, null_from, null_head, null_tail, null_if, null_filter, null_sieve, null_HEAD, null_TAIL, null_IF, null_FILTER, null_SIEVE, const, const1

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

(26)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0)))) [1]
   FROM(z0) -> c1(FROM(s(z0))) [1]
   HEAD(cons(z0, z1)) -> c2 [1]
   TAIL(cons(z0, z1)) -> c3 [1]
   IF(true, z0, z1) -> c4 [1]
   IF(false, z0, z1) -> c5 [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   primes -> sieve(from(s(s(0)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   head(cons(z0, z1)) -> z0 [0]
   tail(cons(z0, z1)) -> z1 [0]
   if(true, z0, z1) -> z0 [0]
   if(false, z0, z1) -> z1 [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]
   primes -> null_primes [0]
   from(v0) -> null_from [0]
   head(v0) -> null_head [0]
   tail(v0) -> null_tail [0]
   if(v0, v1, v2) -> null_if [0]
   filter(v0, v1) -> null_filter [0]
   sieve(v0) -> null_sieve [0]
   HEAD(v0) -> null_HEAD [0]
   TAIL(v0) -> null_TAIL [0]
   IF(v0, v1, v2) -> null_IF [0]
   FILTER(v0, v1) -> null_FILTER [0]
   SIEVE(v0) -> null_SIEVE [0]

The TRS has the following type information:
PRIMES :: c
c :: c8:null_SIEVE -> c1 -> c
SIEVE :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> c8:null_SIEVE
from :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
s :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
0 :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
FROM :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> c1
c1 :: c1 -> c1
HEAD :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> c2:null_HEAD
cons :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
c2 :: c2:null_HEAD
TAIL :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> c3:null_TAIL
c3 :: c3:null_TAIL
IF :: true:false:divides -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> c4:c5:null_IF
true :: true:false:divides
c4 :: c4:c5:null_IF
false :: true:false:divides
c5 :: c4:c5:null_IF
FILTER :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> c6:c7:null_FILTER
c6 :: c4:c5:null_IF -> c6:c7:null_FILTER -> c6:c7:null_FILTER
divides :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> true:false:divides
filter :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
sieve :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
c7 :: c4:c5:null_IF -> c6:c7:null_FILTER -> c8:null_SIEVE -> c6:c7:null_FILTER
c8 :: c6:c7:null_FILTER -> c8:null_SIEVE -> c8:null_SIEVE
primes :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
head :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
tail :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
if :: true:false:divides -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_primes :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_from :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_head :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_tail :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_if :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_filter :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_sieve :: 0:s:cons:null_primes:null_from:null_head:null_tail:null_if:null_filter:null_sieve
null_HEAD :: c2:null_HEAD
null_TAIL :: c3:null_TAIL
null_IF :: c4:c5:null_IF
null_FILTER :: c6:c7:null_FILTER
null_SIEVE :: c8:null_SIEVE
const :: c
const1 :: c1

Rewrite Strategy: INNERMOST
----------------------------------------

(27) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   c2 => 1
   c3 => 1
   true => 1
   c4 => 1
   false => 0
   c5 => 2
   null_primes => 0
   null_from => 0
   null_head => 0
   null_tail => 0
   null_if => 0
   null_filter => 0
   null_sieve => 0
   null_HEAD => 0
   null_TAIL => 0
   null_IF => 0
   null_FILTER => 0
   null_SIEVE => 0
   const => 0
   const1 => 0

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

(28)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, filter(1 + (1 + z0), z2), 1 + z1 + filter(z0, sieve(z1))) + FILTER(1 + (1 + z0), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + IF(1 + (1 + (1 + z0)) + z1, filter(1 + (1 + z0), z2), 1 + z1 + filter(z0, sieve(z1))) + FILTER(z0, sieve(z1)) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z0) :|: z = z0, z0 >= 0
   HEAD(z) -{ 1 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   HEAD(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   IF(z, z', z'') -{ 1 }-> 2 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   IF(z, z', z'') -{ 1 }-> 1 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   IF(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   PRIMES -{ 1 }-> 1 + SIEVE(from(1 + (1 + 0))) + FROM(1 + (1 + 0)) :|: 
   SIEVE(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, sieve(z1)) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   TAIL(z) -{ 1 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   TAIL(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   filter(z, z') -{ 0 }-> if(1 + (1 + (1 + z0)) + z1, filter(1 + (1 + z0), z2), 1 + z1 + filter(z0, sieve(z1))) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   from(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   from(z) -{ 0 }-> 1 + z0 + from(1 + z0) :|: z = z0, z0 >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   if(z, z', z'') -{ 0 }-> z0 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 0, z' = z0, z'' = z1
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   primes -{ 0 }-> sieve(from(1 + (1 + 0))) :|: 
   primes -{ 0 }-> 0 :|: 
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, sieve(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

Only complete derivations are relevant for the runtime complexity.

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

(29) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS to CDT
----------------------------------------

(30)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
Tuples:
   PRIMES' -> c9(SIEVE'(from(s(s(0)))), FROM'(s(s(0))))
   FROM'(z0) -> c10(FROM'(s(z0)))
   HEAD'(cons(z0, z1)) -> c11
   TAIL'(cons(z0, z1)) -> c12
   IF'(true, z0, z1) -> c13
   IF'(false, z0, z1) -> c14
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(IF'(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   PRIMES'' -> c17(SIEVE''(from(s(s(0)))), FROM'(s(s(0))), FROM''(s(s(0))))
   FROM''(z0) -> c18(FROM''(s(z0)))
   HEAD''(cons(z0, z1)) -> c19
   TAIL''(cons(z0, z1)) -> c20
   IF''(true, z0, z1) -> c21
   IF''(false, z0, z1) -> c22
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
S tuples:
   PRIMES'' -> c17(SIEVE''(from(s(s(0)))), FROM'(s(s(0))), FROM''(s(s(0))))
   FROM''(z0) -> c18(FROM''(s(z0)))
   HEAD''(cons(z0, z1)) -> c19
   TAIL''(cons(z0, z1)) -> c20
   IF''(true, z0, z1) -> c21
   IF''(false, z0, z1) -> c22
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
K tuples:none
Defined Rule Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1, primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES', FROM'_1, HEAD'_1, TAIL'_1, IF'_3, FILTER'_2, SIEVE'_1, PRIMES'', FROM''_1, HEAD''_1, TAIL''_1, IF''_3, FILTER''_2, SIEVE''_1

Compound Symbols:   c9_2, c10_1, c11, c12, c13, c14, c15_4, c16_2, c17_3, c18_1, c19, c20, c21, c22, c23_5, c24_7, c25_3


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

(31) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 8 trailing nodes:
   IF''(false, z0, z1) -> c22
   HEAD''(cons(z0, z1)) -> c19
   TAIL''(cons(z0, z1)) -> c20
   IF'(false, z0, z1) -> c14
   TAIL'(cons(z0, z1)) -> c12
   IF''(true, z0, z1) -> c21
   HEAD'(cons(z0, z1)) -> c11
   IF'(true, z0, z1) -> c13

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

(32)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
Tuples:
   PRIMES' -> c9(SIEVE'(from(s(s(0)))), FROM'(s(s(0))))
   FROM'(z0) -> c10(FROM'(s(z0)))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(IF'(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   PRIMES'' -> c17(SIEVE''(from(s(s(0)))), FROM'(s(s(0))), FROM''(s(s(0))))
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
S tuples:
   PRIMES'' -> c17(SIEVE''(from(s(s(0)))), FROM'(s(s(0))), FROM''(s(s(0))))
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(IF''(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
K tuples:none
Defined Rule Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1, primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES', FROM'_1, FILTER'_2, SIEVE'_1, PRIMES'', FROM''_1, FILTER''_2, SIEVE''_1

Compound Symbols:   c9_2, c10_1, c15_4, c16_2, c17_3, c18_1, c23_5, c24_7, c25_3


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

(33) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(34)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
Tuples:
   PRIMES' -> c9(SIEVE'(from(s(s(0)))), FROM'(s(s(0))))
   FROM'(z0) -> c10(FROM'(s(z0)))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   PRIMES'' -> c17(SIEVE''(from(s(s(0)))), FROM'(s(s(0))), FROM''(s(s(0))))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
S tuples:
   PRIMES'' -> c17(SIEVE''(from(s(s(0)))), FROM'(s(s(0))), FROM''(s(s(0))))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
K tuples:none
Defined Rule Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1, primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES', FROM'_1, SIEVE'_1, PRIMES'', FROM''_1, SIEVE''_1, FILTER'_2, FILTER''_2

Compound Symbols:   c9_2, c10_1, c16_2, c17_3, c18_1, c25_3, c15_3, c23_4, c24_6


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

(35) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(36)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES' -> c11(FROM'(s(s(0))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   PRIMES'' -> c11(FROM'(s(s(0))))
   PRIMES'' -> c11(FROM''(s(s(0))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   PRIMES'' -> c11(FROM'(s(s(0))))
   PRIMES'' -> c11(FROM''(s(s(0))))
K tuples:none
Defined Rule Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1, primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   FROM'_1, SIEVE'_1, FROM''_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c16_2, c18_1, c25_3, c15_3, c23_4, c24_6, c11_1


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

(37) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 3 leading nodes:
   PRIMES' -> c11(FROM'(s(s(0))))
   PRIMES'' -> c11(FROM'(s(s(0))))
   PRIMES'' -> c11(FROM''(s(s(0))))

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

(38)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
K tuples:none
Defined Rule Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1, primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   FROM'_1, SIEVE'_1, FROM''_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c16_2, c18_1, c25_3, c15_3, c23_4, c24_6, c11_1


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

(39) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))

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

(40)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1, primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   FROM'_1, SIEVE'_1, FROM''_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c16_2, c18_1, c25_3, c15_3, c23_4, c24_6, c11_1


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

(41) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   primes -> sieve(from(s(s(0))))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

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

(42)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, SIEVE'_1, FROM''_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c16_2, c18_1, c25_3, c15_3, c23_4, c24_6, c11_1


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

(43) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE'(cons(z0, z1)) -> c16(FILTER'(z0, sieve(z1)), SIEVE'(z1)) by 
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))

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

(44)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', SIEVE'_1

Compound Symbols:   c10_1, c18_1, c25_3, c15_3, c23_4, c24_6, c11_1, c16_2


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

(45) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE''(cons(z0, z1)) -> c25(FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1)) by 
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))

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

(46)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', SIEVE'_1, SIEVE''_1

Compound Symbols:   c10_1, c18_1, c15_3, c23_4, c24_6, c11_1, c16_2, c25_3


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

(47) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER'(s(s(z0)), cons(z1, z2)) -> c15(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1)) by 
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))

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

(48)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, FILTER''_2, PRIMES', PRIMES'', SIEVE'_1, SIEVE''_1, FILTER'_2

Compound Symbols:   c10_1, c18_1, c23_4, c24_6, c11_1, c16_2, c25_3, c15_3, c15_1


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

(49) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER''(s(s(z0)), cons(z1, z2)) -> c23(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(s(s(z0)), z2)) by 
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))

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

(50)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, FILTER''_2, PRIMES', PRIMES'', SIEVE'_1, SIEVE''_1, FILTER'_2

Compound Symbols:   c10_1, c18_1, c24_6, c11_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2


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

(51) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER''(s(s(z0)), cons(z1, z2)) -> c24(FILTER'(s(s(z0)), z2), FILTER'(z0, sieve(z1)), SIEVE'(z1), FILTER''(z0, sieve(z1)), SIEVE'(z1), SIEVE''(z1)) by 
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))

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

(52)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   PRIMES' -> c11(SIEVE'(from(s(s(0)))))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, PRIMES', PRIMES'', SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2

Compound Symbols:   c10_1, c18_1, c11_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_6, c24_1


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

(53) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PRIMES' -> c11(SIEVE'(from(s(s(0))))) by 
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), from(s(s(s(0)))))))

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

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), from(s(s(s(0)))))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, PRIMES'', SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES'

Compound Symbols:   c10_1, c18_1, c11_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_6, c24_1


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

(55) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PRIMES'' -> c11(SIEVE''(from(s(s(0))))) by 
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), from(s(s(s(0)))))))

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

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), from(s(s(s(0)))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), from(s(s(s(0)))))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_6, c24_1, c11_1


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

(57) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c24(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, sieve(cons(z0, z1))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1))) by 
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), from(s(s(s(0)))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), from(s(s(s(0)))))))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c11_1, c24_6


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

(59) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PRIMES' -> c11(SIEVE'(cons(s(s(0)), from(s(s(s(0))))))) by 
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))

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

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), from(s(s(s(0)))))))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES'', PRIMES'

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c11_1, c24_6


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

(61) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PRIMES'' -> c11(SIEVE''(cons(s(s(0)), from(s(s(s(0))))))) by 
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(z0) -> c10(FROM'(s(z0)))
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES''

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1


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

(63) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace FROM'(z0) -> c10(FROM'(s(z0))) by 
   FROM'(s(x0)) -> c10(FROM'(s(s(x0))))

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(x0)) -> c10(FROM'(s(s(x0))))
S tuples:
   FROM''(z0) -> c18(FROM''(s(z0)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1

Compound Symbols:   c18_1, c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1


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

(65) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace FROM''(z0) -> c18(FROM''(s(z0))) by 
   FROM''(s(x0)) -> c18(FROM''(s(s(x0))))

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(x0)) -> c10(FROM'(s(s(x0))))
   FROM''(s(x0)) -> c18(FROM''(s(s(x0))))
S tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(x0)) -> c18(FROM''(s(s(x0))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1

Compound Symbols:   c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1


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

(67) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace FROM'(s(x0)) -> c10(FROM'(s(s(x0)))) by 
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM''(s(x0)) -> c18(FROM''(s(s(x0))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
S tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(x0)) -> c18(FROM''(s(s(x0))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM''_1, FROM'_1

Compound Symbols:   c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c18_1, c10_1


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

(69) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace FROM''(s(x0)) -> c18(FROM''(s(s(x0)))) by 
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
S tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   SIEVE'_1, SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1

Compound Symbols:   c16_2, c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1


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

(71) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE'(cons(x0, cons(z0, z1))) -> c16(FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1))) by 
   SIEVE'(cons(z0, cons(z1, cons(y1, y2)))) -> c16(FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(z0, cons(z1, cons(y1, y2)))) -> c16(FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
S tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1, SIEVE'_1

Compound Symbols:   c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2


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

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE'(cons(z0, cons(z1, cons(y1, y2)))) -> c16(FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2)))) by 
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
S tuples:
   SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   SIEVE''_1, FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1, SIEVE'_1

Compound Symbols:   c25_3, c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2


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

(75) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE''(cons(x0, cons(z0, z1))) -> c25(FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1))) by 
   SIEVE''(cons(z0, cons(z1, cons(y1, y2)))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2))), SIEVE''(cons(z1, cons(y1, y2))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(y1, y2)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(z0, cons(z1, cons(y1, y2)))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2))), SIEVE''(cons(z1, cons(y1, y2))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(y1, y2)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(z0, cons(z1, cons(y1, y2)))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2))), SIEVE''(cons(z1, cons(y1, y2))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(y1, y2)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1

Compound Symbols:   c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2, c25_3


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

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE''(cons(z0, cons(z1, cons(y1, y2)))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE'(cons(z1, cons(y1, y2))), SIEVE''(cons(z1, cons(y1, y2)))) by 
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(y1, y2)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(y1, y2)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1

Compound Symbols:   c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2, c25_3


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

(79) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE''(cons(z0, cons(s(s(y0)), cons(y1, y2)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2)))) by 
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1

Compound Symbols:   c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2, c25_3, c25_2


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

(81) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE''(cons(z0, cons(z1, cons(y1, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3))))) by 
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, PRIMES', PRIMES'', FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1

Compound Symbols:   c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2, c25_3, c25_2


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

(83) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0))))))))) by PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
----------------------------------------

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, PRIMES'', FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES'

Compound Symbols:   c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c11_1, c10_1, c18_1, c16_2, c25_3, c25_2


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

(85) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0))))))))) by PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
----------------------------------------

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)))
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_3, c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1


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

(87) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER'(s(s(x0)), cons(cons(z0, z1), x2)) -> c15(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1))) by 
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1, c15_3


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

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER'(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2)))) by 
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1, c15_3


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

(91) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER'(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c15(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3))))) by 
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1, c15_3, c15_2


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

(93) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace SIEVE''(cons(x0, cons(s(s(x1)), cons(z0, z1)))) -> c25(FILTER''(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), SIEVE''(cons(s(s(x1)), cons(z0, z1)))) by SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4)))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1, c15_3, c15_2


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

(95) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace SIEVE''(cons(x0, cons(x1, cons(z0, cons(x3, x4))))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), SIEVE''(cons(x1, cons(z0, cons(x3, x4))))) by SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
----------------------------------------

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1, c15_3, c15_2


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

(97) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0))))))))))) by PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
----------------------------------------

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES'', PRIMES'

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c11_1, c15_3, c15_2


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

(99) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0))))))))))) by PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
----------------------------------------

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_2, c11_1


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

(101) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c15(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1)))) by FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER'_2, FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, PRIMES', PRIMES''

Compound Symbols:   c15_1, c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_2, c11_1


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

(103) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER'(s(s(x0)), cons(x1, x2)) -> c15(FILTER'(s(s(x0)), x2)) by 
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1


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

(105) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1


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

(107) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER'(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4))))) by FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_4, c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1


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

(109) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER''(s(s(x0)), cons(cons(z0, z1), x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(s(s(x0)), x2)) by 
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4


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

(111) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(s(s(z0)), z3)) by 
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c23(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), FILTER''(s(s(x0)), x4))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c23(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), FILTER''(s(s(x0)), x4))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(s(s(z0)), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c23(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), FILTER''(s(s(x0)), x4))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1


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

(113) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c23(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(s(s(z0)), z3)) by 
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c23(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), FILTER''(s(s(x0)), x4))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c23(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), FILTER''(s(s(x0)), x4))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3


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

(115) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c23(FILTER'(s(s(x0)), x4), FILTER'(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(s(s(x1)), cons(z0, z1))), FILTER''(s(s(x0)), x4)) by FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
----------------------------------------

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3


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

(117) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3


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

(119) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER''(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE'(cons(x1, cons(z0, cons(x3, x4)))), FILTER''(s(s(x0)), x5)) by FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c23_2, c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3


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

(121) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER''(s(s(x0)), cons(x1, x2)) -> c23(FILTER'(s(s(x0)), x2), FILTER''(s(s(x0)), x2)) by 
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
S tuples:
   FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2))
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c24_1, c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2


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

(123) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER''(s(s(x0)), cons(x1, x2)) -> c24(FILTER'(s(s(x0)), x2)) by 
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1


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

(125) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
S tuples:
   FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1)))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER''_2, FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES''

Compound Symbols:   c24_6, c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1


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

(127) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER''(s(s(x0)), cons(cons(z0, z1), x3)) -> c24(FILTER'(s(s(x0)), x3), FILTER'(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), FILTER''(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE'(cons(z0, z1)), SIEVE''(cons(z0, z1))) by 
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(129) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE'(cons(x0, cons(x1, cons(z0, z1)))) -> c16(FILTER'(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1)))) by 
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1))))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(131) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE''(cons(x0, cons(x1, cons(z0, z1)))) -> c25(FILTER''(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE'(cons(x1, cons(z0, z1))), SIEVE''(cons(x1, cons(z0, z1)))) by 
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(133) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE''(cons(x0, cons(x1, cons(x2, cons(x3, x4))))) -> c25(SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), SIEVE''(cons(x1, cons(x2, cons(x3, x4))))) by 
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(135) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER''(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE'(cons(s(s(y0)), cons(y1, y2))), SIEVE''(cons(s(s(y0)), cons(y1, y2)))) by FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
----------------------------------------

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(137) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE'(cons(z1, cons(y1, cons(y2, y3)))), SIEVE''(cons(z1, cons(y1, cons(y2, y3))))) by FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
----------------------------------------

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(139) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(y2, y3))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(s(s(y1)), cons(y2, y3)))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3))))) by FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(z2)), cons(z3, z4)))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(s(s(z2)), filter(s(s(z2)), sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
----------------------------------------

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(z2)), cons(z3, z4)))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(s(s(z2)), filter(s(s(z2)), sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(z2)), cons(z3, z4)))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(s(s(z2)), filter(s(s(z2)), sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6


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

(141) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER''(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, cons(y3, y4)))), z3)) -> c24(FILTER'(s(s(z0)), z3), FILTER'(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), FILTER''(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, cons(y3, y4))))))), SIEVE'(cons(z1, cons(y1, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(y1, cons(y2, cons(y3, y4)))))) by FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c24(FILTER'(s(s(z0)), z6), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, cons(z4, z5))))))), SIEVE'(cons(z1, cons(z2, cons(z3, cons(z4, z5))))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, cons(z4, z5)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, cons(z4, z5))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
----------------------------------------

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM'(s(s(x0))) -> c10(FROM'(s(s(s(x0)))))
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE'(cons(s(s(y0)), cons(z1, z2))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c15(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)))
   FILTER'(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c15(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER'(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c15(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   PRIMES' -> c11(SIEVE'(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   PRIMES'' -> c11(SIEVE''(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER'(s(s(z0)), cons(z1, cons(y1, y2))) -> c15(FILTER'(s(s(z0)), cons(y1, y2)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER'(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c15(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER'(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c15(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER'(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c15(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER'(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c15(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))))
   FILTER'(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c15(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE'(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c16(FILTER'(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))))
   SIEVE'(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c16(FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE'(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE'(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c16(FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(z2)), cons(z3, z4)))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(s(s(z2)), filter(s(s(z2)), sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c24(FILTER'(s(s(z0)), z6), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, cons(z4, z5))))))), SIEVE'(cons(z1, cons(z2, cons(z3, cons(z4, z5))))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, cons(z4, z5)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, cons(z4, z5))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
S tuples:
   FROM''(s(s(x0))) -> c18(FROM''(s(s(s(x0)))))
   SIEVE''(cons(s(s(y0)), cons(z1, z2))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(x0, cons(s(s(x1)), cons(x2, x3)))) -> c25(SIEVE'(cons(s(s(x1)), cons(x2, x3))), SIEVE''(cons(s(s(x1)), cons(x2, x3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), z3))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), z3))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c23(SIEVE'(cons(s(s(x1)), cons(x2, x3))))
   FILTER''(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c23(FILTER'(s(s(x0)), x5), SIEVE'(cons(x1, cons(x2, cons(x3, x4)))), FILTER''(s(s(x0)), x5))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c23(FILTER'(s(s(z0)), z4), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(s(s(z0)), z4))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c23(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(s(s(z0)), z5))
   FILTER''(s(s(z0)), cons(z1, cons(y1, y2))) -> c23(FILTER'(s(s(z0)), cons(y1, y2)), FILTER''(s(s(z0)), cons(y1, y2)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), y3)), FILTER''(s(s(z0)), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c23(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER''(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER''(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER''(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER''(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER''(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c23(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER''(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(cons(y5, y6), y7)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, cons(cons(y1, y2), y3))) -> c23(FILTER'(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)), FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), cons(y5, y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(s(s(y3)), cons(y4, y5)), y6))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7)))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, cons(y4, cons(y5, y6))), y7))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(y4, y5))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(cons(y6, y7), y8))))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6))))) -> c23(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))), FILTER''(s(s(s(s(y0)))), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), y6)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7)))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, y5), cons(y6, y7))))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(s(s(y4)), cons(y5, y6)), y7)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8))))) -> c23(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))), FILTER''(s(s(z0)), cons(cons(y1, y2), cons(y3, cons(cons(y4, cons(y5, cons(y6, y7))), y8)))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))))
   FILTER''(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)))
   FILTER''(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))))
   FILTER''(s(s(s(s(y0)))), cons(z1, cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER''(s(s(z0)), cons(z1, cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(y0)))), z3), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(cons(y3, y4), y5)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(cons(y3, y4), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(cons(y1, y2), y3))) -> c24(FILTER'(s(s(s(s(y0)))), cons(cons(y1, y2), y3)), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(y0)))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(y0)))))), z3), FILTER'(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, y2), cons(y3, y4)))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, y2), cons(y3, y4))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(s(s(y1)), cons(y2, y3)), y4))) -> c24(FILTER'(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), y4)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(cons(y1, cons(y2, cons(y3, y4))), y5))) -> c24(FILTER'(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), y5)), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(y2, y3)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(y2, y3))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(cons(y4, y5), y6)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(y0)))), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), y4)))) -> c24(FILTER'(s(s(s(s(y0)))), cons(y1, cons(cons(y2, y3), y4))), FILTER'(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, y3), cons(y4, y5))))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, y3), cons(y4, y5)))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(s(s(y2)), cons(y3, y4)), y5))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(z0)), cons(cons(z1, z2), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c24(FILTER'(s(s(z0)), cons(y1, cons(cons(y2, cons(y3, cons(y4, y5))), y6))), FILTER'(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(z0, cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(cons(z1, z2), z3)) -> c24(FILTER'(s(s(s(s(s(s(s(s(y0)))))))), z3), FILTER'(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, sieve(z2)))), SIEVE'(cons(z1, z2)), SIEVE''(cons(z1, z2)))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(y0)), cons(z2, z3))), SIEVE''(cons(s(s(y0)), cons(z2, z3))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(z2, cons(y2, y3)))), SIEVE''(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(y2, y3))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), sieve(cons(y2, y3))))))), SIEVE'(cons(z1, cons(s(s(y1)), cons(y2, y3)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(y2, y3)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(y2, cons(y3, y4)))))) -> c25(FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, cons(y3, y4)))))))), SIEVE'(cons(z1, cons(z2, cons(y2, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(y2, cons(y3, y4))))))
   SIEVE''(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(y0)))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, cons(z2, z3)))) -> c25(FILTER''(s(s(s(s(s(s(s(s(y0)))))))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(z1, cons(z2, z3))), SIEVE''(cons(z1, cons(z2, z3))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(y0)), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3))))) -> c25(FILTER''(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(y2, y3)))))
   SIEVE''(cons(z0, cons(s(s(y0)), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(y0)), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, z4))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))), SIEVE''(cons(z1, cons(z2, cons(s(s(y2)), cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5))))))) -> c25(SIEVE'(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(y3, cons(y4, y5)))))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(y0)))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4))))) -> c25(SIEVE'(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))), SIEVE''(cons(s(s(s(s(s(s(s(s(y0)))))))), cons(z2, cons(z3, z4)))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(y1)), cons(z3, cons(y3, y4))))))
   SIEVE''(cons(z0, cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4)))))) -> c25(SIEVE'(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))), SIEVE''(cons(z1, cons(s(s(s(s(y1)))), cons(z3, cons(y3, y4))))))
   FILTER''(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c24(FILTER'(s(s(z0)), z4), FILTER'(z0, cons(s(s(z1)), filter(s(s(z1)), sieve(cons(z2, z3))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), FILTER''(z0, cons(s(s(z1)), filter(s(s(z1)), cons(z2, filter(z2, sieve(z3)))))), SIEVE'(cons(s(s(z1)), cons(z2, z3))), SIEVE''(cons(s(s(z1)), cons(z2, z3))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, z4)))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(z2, cons(z3, z4)))), SIEVE''(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c24(FILTER'(s(s(z0)), z5), FILTER'(z0, cons(z1, filter(z1, sieve(cons(s(s(z2)), cons(z3, z4)))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), FILTER''(z0, cons(z1, filter(z1, cons(s(s(z2)), filter(s(s(z2)), sieve(cons(z3, z4))))))), SIEVE'(cons(z1, cons(s(s(z2)), cons(z3, z4)))), SIEVE''(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER''(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c24(FILTER'(s(s(z0)), z6), FILTER'(z0, cons(z1, filter(z1, sieve(cons(z2, cons(z3, cons(z4, z5))))))), SIEVE'(cons(z1, cons(z2, cons(z3, cons(z4, z5))))), FILTER''(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(z3, cons(z4, z5)))))))), SIEVE'(cons(z1, cons(z2, cons(z3, cons(z4, z5))))), SIEVE''(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
K tuples:
   PRIMES'' -> c11(SIEVE''(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM'_1, FROM''_1, SIEVE'_1, SIEVE''_1, FILTER'_2, PRIMES', PRIMES'', FILTER''_2

Compound Symbols:   c10_1, c18_1, c16_2, c25_3, c25_2, c15_3, c15_1, c15_2, c11_1, c23_4, c23_1, c23_3, c23_2, c24_1, c24_6