YES

Problem 1: 

(VAR v_NonEmpty:S X:S X1:S X2:S X3:S Y:S Z:S)
(RULES
active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
active(add(0,X:S)) -> mark(X:S)
active(and(ffalse,Y:S)) -> mark(ffalse)
active(and(ttrue,X:S)) -> mark(X:S)
active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
active(first(0,X:S)) -> mark(nil)
active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
active(if(ttrue,X:S,Y:S)) -> mark(X:S)
add(active(X1:S),X2:S) -> add(X1:S,X2:S)
add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
and(active(X1:S),X2:S) -> and(X1:S,X2:S)
and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
first(active(X1:S),X2:S) -> first(X1:S,X2:S)
first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
from(active(X:S)) -> from(X:S)
from(mark(X:S)) -> from(X:S)
if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
mark(from(X:S)) -> active(from(X:S))
mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
mark(s(X:S)) -> active(s(X:S))
mark(0) -> active(0)
mark(ffalse) -> active(ffalse)
mark(nil) -> active(nil)
mark(ttrue) -> active(ttrue)
s(active(X:S)) -> s(X:S)
s(mark(X:S)) -> s(X:S)
) 
(STRATEGY INNERMOST)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 ACTIVE(add(s(X:S),Y:S)) -> ADD(X:S,Y:S)
 ACTIVE(add(s(X:S),Y:S)) -> MARK(s(add(X:S,Y:S)))
 ACTIVE(add(s(X:S),Y:S)) -> S(add(X:S,Y:S))
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ffalse,Y:S)) -> MARK(ffalse)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> CONS(Y:S,first(X:S,Z:S))
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> FIRST(X:S,Z:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(first(0,X:S)) -> MARK(nil)
 ACTIVE(from(X:S)) -> CONS(X:S,from(s(X:S)))
 ACTIVE(from(X:S)) -> FROM(s(X:S))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(from(X:S)) -> S(X:S)
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 ADD(active(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(mark(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
 AND(active(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(mark(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
 CONS(active(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(mark(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
 FIRST(active(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(mark(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
 FROM(active(X:S)) -> FROM(X:S)
 FROM(mark(X:S)) -> FROM(X:S)
 IF(active(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(mark(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> ADD(mark(X1:S),X2:S)
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> AND(mark(X1:S),X2:S)
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(cons(X1:S,X2:S)) -> ACTIVE(cons(X1:S,X2:S))
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> FIRST(mark(X1:S),mark(X2:S))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> IF(mark(X1:S),X2:S,X3:S)
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
 MARK(s(X:S)) -> ACTIVE(s(X:S))
 S(active(X:S)) -> S(X:S)
 S(mark(X:S)) -> S(X:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1: 

SCC Processor:
-> Pairs:
 ACTIVE(add(s(X:S),Y:S)) -> ADD(X:S,Y:S)
 ACTIVE(add(s(X:S),Y:S)) -> MARK(s(add(X:S,Y:S)))
 ACTIVE(add(s(X:S),Y:S)) -> S(add(X:S,Y:S))
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ffalse,Y:S)) -> MARK(ffalse)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> CONS(Y:S,first(X:S,Z:S))
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> FIRST(X:S,Z:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(first(0,X:S)) -> MARK(nil)
 ACTIVE(from(X:S)) -> CONS(X:S,from(s(X:S)))
 ACTIVE(from(X:S)) -> FROM(s(X:S))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(from(X:S)) -> S(X:S)
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 ADD(active(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(mark(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
 AND(active(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(mark(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
 CONS(active(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(mark(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
 FIRST(active(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(mark(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
 FROM(active(X:S)) -> FROM(X:S)
 FROM(mark(X:S)) -> FROM(X:S)
 IF(active(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(mark(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> ADD(mark(X1:S),X2:S)
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> AND(mark(X1:S),X2:S)
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(cons(X1:S,X2:S)) -> ACTIVE(cons(X1:S,X2:S))
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> FIRST(mark(X1:S),mark(X2:S))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> IF(mark(X1:S),X2:S,X3:S)
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
 MARK(s(X:S)) -> ACTIVE(s(X:S))
 S(active(X:S)) -> S(X:S)
 S(mark(X:S)) -> S(X:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 S(active(X:S)) -> S(X:S)
 S(mark(X:S)) -> S(X:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 IF(active(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(mark(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 FROM(active(X:S)) -> FROM(X:S)
 FROM(mark(X:S)) -> FROM(X:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 FIRST(active(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(mark(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 CONS(active(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(mark(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 AND(active(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(mark(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 ADD(active(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(mark(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->->Cycle:
->->-> Pairs:
 ACTIVE(add(s(X:S),Y:S)) -> MARK(s(add(X:S,Y:S)))
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)


The problem is decomposed in 8 subproblems.

Problem 1.1: 

Subterm Processor:
-> Pairs:
 S(active(X:S)) -> S(X:S)
 S(mark(X:S)) -> S(X:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(S) = 1

Problem 1.1: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.2: 

Subterm Processor:
-> Pairs:
 IF(active(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(mark(X1:S),X2:S,X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(IF) = 1

Problem 1.2: 

SCC Processor:
-> Pairs:
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.2: 

Subterm Processor:
-> Pairs:
 IF(X1:S,active(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,mark(X2:S),X3:S) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(IF) = 2

Problem 1.2: 

SCC Processor:
-> Pairs:
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.2: 

Subterm Processor:
-> Pairs:
 IF(X1:S,X2:S,active(X3:S)) -> IF(X1:S,X2:S,X3:S)
 IF(X1:S,X2:S,mark(X3:S)) -> IF(X1:S,X2:S,X3:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(IF) = 3

Problem 1.2: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.3: 

Subterm Processor:
-> Pairs:
 FROM(active(X:S)) -> FROM(X:S)
 FROM(mark(X:S)) -> FROM(X:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(FROM) = 1

Problem 1.3: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.4: 

Subterm Processor:
-> Pairs:
 FIRST(active(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(mark(X1:S),X2:S) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(FIRST) = 1

Problem 1.4: 

SCC Processor:
-> Pairs:
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.4: 

Subterm Processor:
-> Pairs:
 FIRST(X1:S,active(X2:S)) -> FIRST(X1:S,X2:S)
 FIRST(X1:S,mark(X2:S)) -> FIRST(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(FIRST) = 2

Problem 1.4: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.5: 

Subterm Processor:
-> Pairs:
 CONS(active(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(mark(X1:S),X2:S) -> CONS(X1:S,X2:S)
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(CONS) = 1

Problem 1.5: 

SCC Processor:
-> Pairs:
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.5: 

Subterm Processor:
-> Pairs:
 CONS(X1:S,active(X2:S)) -> CONS(X1:S,X2:S)
 CONS(X1:S,mark(X2:S)) -> CONS(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(CONS) = 2

Problem 1.5: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.6: 

Subterm Processor:
-> Pairs:
 AND(active(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(mark(X1:S),X2:S) -> AND(X1:S,X2:S)
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(AND) = 1

Problem 1.6: 

SCC Processor:
-> Pairs:
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.6: 

Subterm Processor:
-> Pairs:
 AND(X1:S,active(X2:S)) -> AND(X1:S,X2:S)
 AND(X1:S,mark(X2:S)) -> AND(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(AND) = 2

Problem 1.6: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.7: 

Subterm Processor:
-> Pairs:
 ADD(active(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(mark(X1:S),X2:S) -> ADD(X1:S,X2:S)
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(ADD) = 1

Problem 1.7: 

SCC Processor:
-> Pairs:
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.7: 

Subterm Processor:
-> Pairs:
 ADD(X1:S,active(X2:S)) -> ADD(X1:S,X2:S)
 ADD(X1:S,mark(X2:S)) -> ADD(X1:S,X2:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(ADD) = 2

Problem 1.7: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(add(s(X:S),Y:S)) -> MARK(s(add(X:S,Y:S)))
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[add](X1,X2) = 2.X1 + 2.X2 + 2
[and](X1,X2) = 2.X1 + 2.X2 + 2
[cons](X1,X2) = 0
[first](X1,X2) = X1 + 2.X2 + 2
[from](X) = X + 2
[if](X1,X2,X3) = 2.X1 + 2.X2 + 2.X3 + 1
[mark](X) = 2.X + 1
[s](X) = 2
[0] = 2
[fSNonEmpty] = 0
[false] = 2
[nil] = 1
[true] = 0
[ACTIVE](X) = X + 1
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X + 2
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(add(0,X:S)) -> MARK(X:S)
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[add](X1,X2) = 2.X1 + 2.X2 + 1
[and](X1,X2) = X1 + 2.X2 + 2
[cons](X1,X2) = 0
[first](X1,X2) = 2.X1 + 2.X2 + 2
[from](X) = 2.X + 2
[if](X1,X2,X3) = 2.X1 + 2.X2 + 2.X3 + 1
[mark](X) = 2.X
[s](X) = 2
[0] = 2
[fSNonEmpty] = 0
[false] = 2
[nil] = 0
[true] = 2
[ACTIVE](X) = X + 2
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X + 2
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(and(ttrue,X:S)) -> MARK(X:S)
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X + 2
[add](X1,X2) = 2.X1 + 2.X2 + 2
[and](X1,X2) = 2.X1 + 2.X2 + 2
[cons](X1,X2) = X1 + 2
[first](X1,X2) = 2.X1 + 2.X2 + 2
[from](X) = 2.X + 2
[if](X1,X2,X3) = X1 + 2.X2 + 2.X3 + 2
[mark](X) = 2.X
[s](X) = 2
[0] = 2
[fSNonEmpty] = 0
[false] = 2
[nil] = 2
[true] = 2
[ACTIVE](X) = X + 2
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(first(s(X:S),cons(Y:S,Z:S))) -> MARK(cons(Y:S,first(X:S,Z:S)))
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X + 2
[add](X1,X2) = X1 + 2.X2 + 2
[and](X1,X2) = 2.X1 + 2.X2 + 2
[cons](X1,X2) = X1 + 2
[first](X1,X2) = 2.X1 + 2.X2 + 2
[from](X) = 2.X + 2
[if](X1,X2,X3) = 2.X1 + 2.X2 + 2.X3 + 2
[mark](X) = 2.X
[s](X) = 2
[0] = 2
[fSNonEmpty] = 0
[false] = 2
[nil] = 2
[true] = 2
[ACTIVE](X) = X + 2
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(from(X:S)) -> MARK(cons(X:S,from(s(X:S))))
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[add](X1,X2) = 2.X1 + 2.X2 + 1
[and](X1,X2) = 2.X1 + 2.X2 + 2
[cons](X1,X2) = 0
[first](X1,X2) = 2.X1 + X2 + 2
[from](X) = 2
[if](X1,X2,X3) = 2.X1 + 2.X2 + 2.X3 + 2
[mark](X) = 2.X + 1
[s](X) = 1
[0] = 2
[fSNonEmpty] = 0
[false] = 2
[nil] = 2
[true] = 1
[ACTIVE](X) = X + 1
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X + 2
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(from(X:S)) -> ACTIVE(from(X:S))
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(if(ffalse,X:S,Y:S)) -> MARK(Y:S)
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[add](X1,X2) = 2.X1 + 2.X2 + 2
[and](X1,X2) = 2.X1 + 2.X2 + 2
[cons](X1,X2) = 0
[first](X1,X2) = X1 + X2 + 2
[from](X) = 2
[if](X1,X2,X3) = 2.X1 + 2.X2 + 2.X3 + 2
[mark](X) = 2.X + 2
[s](X) = 2
[0] = 2
[fSNonEmpty] = 0
[false] = 2
[nil] = 1
[true] = 2
[ACTIVE](X) = X
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X + 2
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Reduction Pairs Processor:
-> Pairs:
 ACTIVE(if(ttrue,X:S,Y:S)) -> MARK(X:S)
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
-> Usable rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[active](X) = X
[add](X1,X2) = X1 + 2.X2 + 2
[and](X1,X2) = 2.X1 + 2.X2 + 2
[cons](X1,X2) = X1 + 1
[first](X1,X2) = 2.X1 + 2.X2 + 2
[from](X) = 2.X + 2
[if](X1,X2,X3) = 2.X1 + 2.X2 + 2.X3 + 2
[mark](X) = 2.X
[s](X) = 2
[0] = 2
[fSNonEmpty] = 0
[false] = 0
[nil] = 2
[true] = 2
[ACTIVE](X) = X + 2
[ADD](X1,X2) = 0
[AND](X1,X2) = 0
[CONS](X1,X2) = 0
[FIRST](X1,X2) = 0
[FROM](X) = 0
[IF](X1,X2,X3) = 0
[MARK](X) = 2.X + 1
[S](X) = 0

Problem 1.8: 

SCC Processor:
-> Pairs:
 MARK(add(X1:S,X2:S)) -> ACTIVE(add(mark(X1:S),X2:S))
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> ACTIVE(and(mark(X1:S),X2:S))
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> ACTIVE(first(mark(X1:S),mark(X2:S)))
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> ACTIVE(if(mark(X1:S),X2:S,X3:S))
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
->->-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)

Problem 1.8: 

Subterm Processor:
-> Pairs:
 MARK(add(X1:S,X2:S)) -> MARK(X1:S)
 MARK(and(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X1:S)
 MARK(first(X1:S,X2:S)) -> MARK(X2:S)
 MARK(if(X1:S,X2:S,X3:S)) -> MARK(X1:S)
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Projection:
 pi(MARK) = 1

Problem 1.8: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 active(add(s(X:S),Y:S)) -> mark(s(add(X:S,Y:S)))
 active(add(0,X:S)) -> mark(X:S)
 active(and(ffalse,Y:S)) -> mark(ffalse)
 active(and(ttrue,X:S)) -> mark(X:S)
 active(first(s(X:S),cons(Y:S,Z:S))) -> mark(cons(Y:S,first(X:S,Z:S)))
 active(first(0,X:S)) -> mark(nil)
 active(from(X:S)) -> mark(cons(X:S,from(s(X:S))))
 active(if(ffalse,X:S,Y:S)) -> mark(Y:S)
 active(if(ttrue,X:S,Y:S)) -> mark(X:S)
 add(active(X1:S),X2:S) -> add(X1:S,X2:S)
 add(mark(X1:S),X2:S) -> add(X1:S,X2:S)
 add(X1:S,active(X2:S)) -> add(X1:S,X2:S)
 add(X1:S,mark(X2:S)) -> add(X1:S,X2:S)
 and(active(X1:S),X2:S) -> and(X1:S,X2:S)
 and(mark(X1:S),X2:S) -> and(X1:S,X2:S)
 and(X1:S,active(X2:S)) -> and(X1:S,X2:S)
 and(X1:S,mark(X2:S)) -> and(X1:S,X2:S)
 cons(active(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(mark(X1:S),X2:S) -> cons(X1:S,X2:S)
 cons(X1:S,active(X2:S)) -> cons(X1:S,X2:S)
 cons(X1:S,mark(X2:S)) -> cons(X1:S,X2:S)
 first(active(X1:S),X2:S) -> first(X1:S,X2:S)
 first(mark(X1:S),X2:S) -> first(X1:S,X2:S)
 first(X1:S,active(X2:S)) -> first(X1:S,X2:S)
 first(X1:S,mark(X2:S)) -> first(X1:S,X2:S)
 from(active(X:S)) -> from(X:S)
 from(mark(X:S)) -> from(X:S)
 if(active(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(mark(X1:S),X2:S,X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,active(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,mark(X2:S),X3:S) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,active(X3:S)) -> if(X1:S,X2:S,X3:S)
 if(X1:S,X2:S,mark(X3:S)) -> if(X1:S,X2:S,X3:S)
 mark(add(X1:S,X2:S)) -> active(add(mark(X1:S),X2:S))
 mark(and(X1:S,X2:S)) -> active(and(mark(X1:S),X2:S))
 mark(cons(X1:S,X2:S)) -> active(cons(X1:S,X2:S))
 mark(first(X1:S,X2:S)) -> active(first(mark(X1:S),mark(X2:S)))
 mark(from(X:S)) -> active(from(X:S))
 mark(if(X1:S,X2:S,X3:S)) -> active(if(mark(X1:S),X2:S,X3:S))
 mark(s(X:S)) -> active(s(X:S))
 mark(0) -> active(0)
 mark(ffalse) -> active(ffalse)
 mark(nil) -> active(nil)
 mark(ttrue) -> active(ttrue)
 s(active(X:S)) -> s(X:S)
 s(mark(X:S)) -> s(X:S)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.