YES

Problem:
 active(U11(tt(),N)) -> mark(N)
 active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
 active(and(tt(),X)) -> mark(X)
 active(isNat(0())) -> mark(tt())
 active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
 active(isNat(s(V1))) -> mark(isNat(V1))
 active(plus(N,0())) -> mark(U11(isNat(N),N))
 active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
 mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
 mark(tt()) -> active(tt())
 mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
 mark(s(X)) -> active(s(mark(X)))
 mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
 mark(and(X1,X2)) -> active(and(mark(X1),X2))
 mark(isNat(X)) -> active(isNat(X))
 mark(0()) -> active(0())
 U11(mark(X1),X2) -> U11(X1,X2)
 U11(X1,mark(X2)) -> U11(X1,X2)
 U11(active(X1),X2) -> U11(X1,X2)
 U11(X1,active(X2)) -> U11(X1,X2)
 U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
 U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
 U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
 U21(active(X1),X2,X3) -> U21(X1,X2,X3)
 U21(X1,active(X2),X3) -> U21(X1,X2,X3)
 U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
 s(mark(X)) -> s(X)
 s(active(X)) -> s(X)
 plus(mark(X1),X2) -> plus(X1,X2)
 plus(X1,mark(X2)) -> plus(X1,X2)
 plus(active(X1),X2) -> plus(X1,X2)
 plus(X1,active(X2)) -> plus(X1,X2)
 and(mark(X1),X2) -> and(X1,X2)
 and(X1,mark(X2)) -> and(X1,X2)
 and(active(X1),X2) -> and(X1,X2)
 and(X1,active(X2)) -> and(X1,X2)
 isNat(mark(X)) -> isNat(X)
 isNat(active(X)) -> isNat(X)

Proof:
 DP Processor:
  DPs:
   active#(U11(tt(),N)) -> mark#(N)
   active#(U21(tt(),M,N)) -> plus#(N,M)
   active#(U21(tt(),M,N)) -> s#(plus(N,M))
   active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
   active#(and(tt(),X)) -> mark#(X)
   active#(isNat(0())) -> mark#(tt())
   active#(isNat(plus(V1,V2))) -> isNat#(V2)
   active#(isNat(plus(V1,V2))) -> isNat#(V1)
   active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
   active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
   active#(isNat(s(V1))) -> isNat#(V1)
   active#(isNat(s(V1))) -> mark#(isNat(V1))
   active#(plus(N,0())) -> isNat#(N)
   active#(plus(N,0())) -> U11#(isNat(N),N)
   active#(plus(N,0())) -> mark#(U11(isNat(N),N))
   active#(plus(N,s(M))) -> isNat#(N)
   active#(plus(N,s(M))) -> isNat#(M)
   active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
   active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
   active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
   mark#(U11(X1,X2)) -> mark#(X1)
   mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
   mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
   mark#(tt()) -> active#(tt())
   mark#(U21(X1,X2,X3)) -> mark#(X1)
   mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
   mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
   mark#(s(X)) -> mark#(X)
   mark#(s(X)) -> s#(mark(X))
   mark#(s(X)) -> active#(s(mark(X)))
   mark#(plus(X1,X2)) -> mark#(X2)
   mark#(plus(X1,X2)) -> mark#(X1)
   mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
   mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
   mark#(and(X1,X2)) -> mark#(X1)
   mark#(and(X1,X2)) -> and#(mark(X1),X2)
   mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
   mark#(isNat(X)) -> active#(isNat(X))
   mark#(0()) -> active#(0())
   U11#(mark(X1),X2) -> U11#(X1,X2)
   U11#(X1,mark(X2)) -> U11#(X1,X2)
   U11#(active(X1),X2) -> U11#(X1,X2)
   U11#(X1,active(X2)) -> U11#(X1,X2)
   U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
   U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
   U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
   U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
   U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
   U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
   s#(mark(X)) -> s#(X)
   s#(active(X)) -> s#(X)
   plus#(mark(X1),X2) -> plus#(X1,X2)
   plus#(X1,mark(X2)) -> plus#(X1,X2)
   plus#(active(X1),X2) -> plus#(X1,X2)
   plus#(X1,active(X2)) -> plus#(X1,X2)
   and#(mark(X1),X2) -> and#(X1,X2)
   and#(X1,mark(X2)) -> and#(X1,X2)
   and#(active(X1),X2) -> and#(X1,X2)
   and#(X1,active(X2)) -> and#(X1,X2)
   isNat#(mark(X)) -> isNat#(X)
   isNat#(active(X)) -> isNat#(X)
  TRS:
   active(U11(tt(),N)) -> mark(N)
   active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
   active(and(tt(),X)) -> mark(X)
   active(isNat(0())) -> mark(tt())
   active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
   active(isNat(s(V1))) -> mark(isNat(V1))
   active(plus(N,0())) -> mark(U11(isNat(N),N))
   active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
   mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
   mark(tt()) -> active(tt())
   mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
   mark(s(X)) -> active(s(mark(X)))
   mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
   mark(and(X1,X2)) -> active(and(mark(X1),X2))
   mark(isNat(X)) -> active(isNat(X))
   mark(0()) -> active(0())
   U11(mark(X1),X2) -> U11(X1,X2)
   U11(X1,mark(X2)) -> U11(X1,X2)
   U11(active(X1),X2) -> U11(X1,X2)
   U11(X1,active(X2)) -> U11(X1,X2)
   U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
   U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
   U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
   U21(active(X1),X2,X3) -> U21(X1,X2,X3)
   U21(X1,active(X2),X3) -> U21(X1,X2,X3)
   U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
   s(mark(X)) -> s(X)
   s(active(X)) -> s(X)
   plus(mark(X1),X2) -> plus(X1,X2)
   plus(X1,mark(X2)) -> plus(X1,X2)
   plus(active(X1),X2) -> plus(X1,X2)
   plus(X1,active(X2)) -> plus(X1,X2)
   and(mark(X1),X2) -> and(X1,X2)
   and(X1,mark(X2)) -> and(X1,X2)
   and(active(X1),X2) -> and(X1,X2)
   and(X1,active(X2)) -> and(X1,X2)
   isNat(mark(X)) -> isNat(X)
   isNat(active(X)) -> isNat(X)
  TDG Processor:
   DPs:
    active#(U11(tt(),N)) -> mark#(N)
    active#(U21(tt(),M,N)) -> plus#(N,M)
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    active#(and(tt(),X)) -> mark#(X)
    active#(isNat(0())) -> mark#(tt())
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    active#(isNat(s(V1))) -> isNat#(V1)
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    active#(plus(N,0())) -> isNat#(N)
    active#(plus(N,0())) -> U11#(isNat(N),N)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    active#(plus(N,s(M))) -> isNat#(N)
    active#(plus(N,s(M))) -> isNat#(M)
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(U11(X1,X2)) -> mark#(X1)
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(tt()) -> active#(tt())
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(plus(X1,X2)) -> mark#(X2)
    mark#(plus(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(and(X1,X2)) -> mark#(X1)
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(isNat(X)) -> active#(isNat(X))
    mark#(0()) -> active#(0())
    U11#(mark(X1),X2) -> U11#(X1,X2)
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    U11#(active(X1),X2) -> U11#(X1,X2)
    U11#(X1,active(X2)) -> U11#(X1,X2)
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X)
    plus#(mark(X1),X2) -> plus#(X1,X2)
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    plus#(active(X1),X2) -> plus#(X1,X2)
    plus#(X1,active(X2)) -> plus#(X1,X2)
    and#(mark(X1),X2) -> and#(X1,X2)
    and#(X1,mark(X2)) -> and#(X1,X2)
    and#(active(X1),X2) -> and#(X1,X2)
    and#(X1,active(X2)) -> and#(X1,X2)
    isNat#(mark(X)) -> isNat#(X)
    isNat#(active(X)) -> isNat#(X)
   TRS:
    active(U11(tt(),N)) -> mark(N)
    active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
    active(and(tt(),X)) -> mark(X)
    active(isNat(0())) -> mark(tt())
    active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
    active(isNat(s(V1))) -> mark(isNat(V1))
    active(plus(N,0())) -> mark(U11(isNat(N),N))
    active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
    mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
    mark(tt()) -> active(tt())
    mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
    mark(s(X)) -> active(s(mark(X)))
    mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
    mark(and(X1,X2)) -> active(and(mark(X1),X2))
    mark(isNat(X)) -> active(isNat(X))
    mark(0()) -> active(0())
    U11(mark(X1),X2) -> U11(X1,X2)
    U11(X1,mark(X2)) -> U11(X1,X2)
    U11(active(X1),X2) -> U11(X1,X2)
    U11(X1,active(X2)) -> U11(X1,X2)
    U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
    U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
    U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
    U21(active(X1),X2,X3) -> U21(X1,X2,X3)
    U21(X1,active(X2),X3) -> U21(X1,X2,X3)
    U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
    s(mark(X)) -> s(X)
    s(active(X)) -> s(X)
    plus(mark(X1),X2) -> plus(X1,X2)
    plus(X1,mark(X2)) -> plus(X1,X2)
    plus(active(X1),X2) -> plus(X1,X2)
    plus(X1,active(X2)) -> plus(X1,X2)
    and(mark(X1),X2) -> and(X1,X2)
    and(X1,mark(X2)) -> and(X1,X2)
    and(active(X1),X2) -> and(X1,X2)
    and(X1,active(X2)) -> and(X1,X2)
    isNat(mark(X)) -> isNat(X)
    isNat(active(X)) -> isNat(X)
   graph:
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    U11#(mark(X1),X2) -> U11#(X1,X2) ->
    U11#(X1,active(X2)) -> U11#(X1,X2)
    U11#(mark(X1),X2) -> U11#(X1,X2) ->
    U11#(active(X1),X2) -> U11#(X1,X2)
    U11#(mark(X1),X2) -> U11#(X1,X2) ->
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    U11#(mark(X1),X2) -> U11#(X1,X2) ->
    U11#(mark(X1),X2) -> U11#(X1,X2)
    U11#(active(X1),X2) -> U11#(X1,X2) ->
    U11#(X1,active(X2)) -> U11#(X1,X2)
    U11#(active(X1),X2) -> U11#(X1,X2) ->
    U11#(active(X1),X2) -> U11#(X1,X2)
    U11#(active(X1),X2) -> U11#(X1,X2) ->
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    U11#(active(X1),X2) -> U11#(X1,X2) ->
    U11#(mark(X1),X2) -> U11#(X1,X2)
    U11#(X1,mark(X2)) -> U11#(X1,X2) ->
    U11#(X1,active(X2)) -> U11#(X1,X2)
    U11#(X1,mark(X2)) -> U11#(X1,X2) ->
    U11#(active(X1),X2) -> U11#(X1,X2)
    U11#(X1,mark(X2)) -> U11#(X1,X2) ->
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    U11#(X1,mark(X2)) -> U11#(X1,X2) ->
    U11#(mark(X1),X2) -> U11#(X1,X2)
    U11#(X1,active(X2)) -> U11#(X1,X2) ->
    U11#(X1,active(X2)) -> U11#(X1,X2)
    U11#(X1,active(X2)) -> U11#(X1,X2) ->
    U11#(active(X1),X2) -> U11#(X1,X2)
    U11#(X1,active(X2)) -> U11#(X1,X2) ->
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    U11#(X1,active(X2)) -> U11#(X1,X2) ->
    U11#(mark(X1),X2) -> U11#(X1,X2)
    and#(mark(X1),X2) -> and#(X1,X2) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    and#(mark(X1),X2) -> and#(X1,X2) ->
    and#(active(X1),X2) -> and#(X1,X2)
    and#(mark(X1),X2) -> and#(X1,X2) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    and#(mark(X1),X2) -> and#(X1,X2) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    and#(active(X1),X2) -> and#(X1,X2) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    and#(active(X1),X2) -> and#(X1,X2) ->
    and#(active(X1),X2) -> and#(X1,X2)
    and#(active(X1),X2) -> and#(X1,X2) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    and#(active(X1),X2) -> and#(X1,X2) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    and#(X1,mark(X2)) -> and#(X1,X2) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    and#(X1,mark(X2)) -> and#(X1,X2) ->
    and#(active(X1),X2) -> and#(X1,X2)
    and#(X1,mark(X2)) -> and#(X1,X2) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    and#(X1,mark(X2)) -> and#(X1,X2) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    and#(X1,active(X2)) -> and#(X1,X2) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    and#(X1,active(X2)) -> and#(X1,X2) ->
    and#(active(X1),X2) -> and#(X1,X2)
    and#(X1,active(X2)) -> and#(X1,X2) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    and#(X1,active(X2)) -> and#(X1,X2) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    isNat#(mark(X)) -> isNat#(X) -> isNat#(active(X)) -> isNat#(X)
    isNat#(mark(X)) -> isNat#(X) -> isNat#(mark(X)) -> isNat#(X)
    isNat#(active(X)) -> isNat#(X) -> isNat#(active(X)) -> isNat#(X)
    isNat#(active(X)) -> isNat#(X) -> isNat#(mark(X)) -> isNat#(X)
    s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
    s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
    plus#(mark(X1),X2) -> plus#(X1,X2) ->
    plus#(X1,active(X2)) -> plus#(X1,X2)
    plus#(mark(X1),X2) -> plus#(X1,X2) ->
    plus#(active(X1),X2) -> plus#(X1,X2)
    plus#(mark(X1),X2) -> plus#(X1,X2) ->
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    plus#(mark(X1),X2) -> plus#(X1,X2) ->
    plus#(mark(X1),X2) -> plus#(X1,X2)
    plus#(active(X1),X2) -> plus#(X1,X2) ->
    plus#(X1,active(X2)) -> plus#(X1,X2)
    plus#(active(X1),X2) -> plus#(X1,X2) ->
    plus#(active(X1),X2) -> plus#(X1,X2)
    plus#(active(X1),X2) -> plus#(X1,X2) ->
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    plus#(active(X1),X2) -> plus#(X1,X2) ->
    plus#(mark(X1),X2) -> plus#(X1,X2)
    plus#(X1,mark(X2)) -> plus#(X1,X2) ->
    plus#(X1,active(X2)) -> plus#(X1,X2)
    plus#(X1,mark(X2)) -> plus#(X1,X2) ->
    plus#(active(X1),X2) -> plus#(X1,X2)
    plus#(X1,mark(X2)) -> plus#(X1,X2) ->
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    plus#(X1,mark(X2)) -> plus#(X1,X2) ->
    plus#(mark(X1),X2) -> plus#(X1,X2)
    plus#(X1,active(X2)) -> plus#(X1,X2) ->
    plus#(X1,active(X2)) -> plus#(X1,X2)
    plus#(X1,active(X2)) -> plus#(X1,X2) ->
    plus#(active(X1),X2) -> plus#(X1,X2)
    plus#(X1,active(X2)) -> plus#(X1,X2) ->
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    plus#(X1,active(X2)) -> plus#(X1,X2) ->
    plus#(mark(X1),X2) -> plus#(X1,X2)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,s(M))) -> isNat#(M)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,s(M))) -> isNat#(N)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(plus(N,0())) -> isNat#(N)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(s(V1))) -> isNat#(V1)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(isNat(0())) -> mark#(tt())
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(and(tt(),X)) -> mark#(X)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(isNat(X)) -> active#(isNat(X)) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(0()) -> active#(0()) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(0()) -> active#(0()) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(0()) -> active#(0()) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(0()) -> active#(0()) -> active#(plus(N,s(M))) -> isNat#(M)
    mark#(0()) -> active#(0()) -> active#(plus(N,s(M))) -> isNat#(N)
    mark#(0()) -> active#(0()) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(0()) -> active#(0()) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(0()) -> active#(0()) -> active#(plus(N,0())) -> isNat#(N)
    mark#(0()) -> active#(0()) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(0()) -> active#(0()) -> active#(isNat(s(V1))) -> isNat#(V1)
    mark#(0()) -> active#(0()) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(0()) -> active#(0()) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(0()) -> active#(0()) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(0()) -> active#(0()) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(0()) -> active#(0()) -> active#(isNat(0())) -> mark#(tt())
    mark#(0()) -> active#(0()) -> active#(and(tt(),X)) -> mark#(X)
    mark#(0()) -> active#(0()) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(0()) -> active#(0()) -> active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(0()) -> active#(0()) -> active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(0()) -> active#(0()) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(and(X1,X2)) -> and#(mark(X1),X2) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    mark#(and(X1,X2)) -> and#(mark(X1),X2) ->
    and#(active(X1),X2) -> and#(X1,X2)
    mark#(and(X1,X2)) -> and#(mark(X1),X2) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    mark#(and(X1,X2)) -> and#(mark(X1),X2) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(isNat(X)) -> active#(isNat(X))
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> mark#(X1)
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(plus(X1,X2)) -> mark#(X1)
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(plus(X1,X2)) -> mark#(X2)
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(and(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(and(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> isNat#(M)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> isNat#(N)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(plus(N,0())) -> isNat#(N)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(s(V1))) -> isNat#(V1)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(isNat(0())) -> mark#(tt())
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(and(tt(),X)) -> mark#(X)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
    mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
    mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
    mark#(s(X)) -> mark#(X) -> mark#(isNat(X)) -> active#(isNat(X))
    mark#(s(X)) -> mark#(X) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(s(X)) -> mark#(X) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(s(X)) -> mark#(X) -> mark#(plus(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) -> mark#(plus(X1,X2)) -> mark#(X2)
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    mark#(s(X)) -> mark#(X) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(s(X)) -> mark#(X) -> mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(s(X)) -> mark#(X) -> mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(s(X)) -> mark#(X) -> mark#(tt()) -> active#(tt())
    mark#(s(X)) -> mark#(X) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(s(X)) -> mark#(X) -> mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(s(X)) -> mark#(X) -> mark#(U11(X1,X2)) -> mark#(X1)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,s(M))) -> isNat#(M)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,s(M))) -> isNat#(N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(plus(N,0())) -> isNat#(N)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(s(V1))) -> isNat#(V1)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(isNat(0())) -> mark#(tt())
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(and(tt(),X)) -> mark#(X)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(s(X)) -> active#(s(mark(X))) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2)) ->
    plus#(X1,active(X2)) -> plus#(X1,X2)
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2)) ->
    plus#(active(X1),X2) -> plus#(X1,X2)
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2)) ->
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2)) ->
    plus#(mark(X1),X2) -> plus#(X1,X2)
    mark#(plus(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(isNat(X)) -> active#(isNat(X))
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(and(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(plus(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X))
    mark#(plus(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X2) -> mark#(tt()) -> active#(tt())
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(plus(X1,X2)) -> mark#(X2) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(isNat(X)) -> active#(isNat(X))
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(plus(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(plus(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(plus(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(plus(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,s(M))) -> isNat#(M)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,s(M))) -> isNat#(N)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(plus(N,0())) -> isNat#(N)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(s(V1))) -> isNat#(V1)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(isNat(0())) -> mark#(tt())
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(and(tt(),X)) -> mark#(X)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(0()) -> active#(0())
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(isNat(X)) -> active#(isNat(X))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> mark#(X1)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(s(X)) -> s#(mark(X))
    mark#(U21(X1,X2,X3)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(tt()) -> active#(tt())
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(U21(X1,X2,X3)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,s(M))) -> isNat#(M)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,s(M))) -> isNat#(N)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(plus(N,0())) -> isNat#(N)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(s(V1))) -> isNat#(V1)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(isNat(0())) -> mark#(tt())
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(and(tt(),X)) -> mark#(X)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2) ->
    U11#(X1,active(X2)) -> U11#(X1,X2)
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2) ->
    U11#(active(X1),X2) -> U11#(X1,X2)
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2) ->
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2) ->
    U11#(mark(X1),X2) -> U11#(X1,X2)
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(isNat(X)) -> active#(isNat(X))
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> mark#(X1)
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(plus(X1,X2)) -> mark#(X1)
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(plus(X1,X2)) -> mark#(X2)
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(s(X)) -> active#(s(mark(X)))
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X))
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    mark#(U11(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    mark#(U11(X1,X2)) -> mark#(X1) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> isNat#(M)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,s(M))) -> isNat#(N)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(plus(N,0())) -> isNat#(N)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(s(V1))) -> isNat#(V1)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(isNat(0())) -> mark#(tt())
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(and(tt(),X)) -> mark#(X)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
    active#(U11(tt(),N)) -> mark#(N)
    mark#(tt()) -> active#(tt()) ->
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    mark#(tt()) -> active#(tt()) ->
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N)
    mark#(tt()) -> active#(tt()) ->
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N))
    mark#(tt()) -> active#(tt()) -> active#(plus(N,s(M))) -> isNat#(M)
    mark#(tt()) -> active#(tt()) -> active#(plus(N,s(M))) -> isNat#(N)
    mark#(tt()) -> active#(tt()) ->
    active#(plus(N,0())) -> mark#(U11(isNat(N),N))
    mark#(tt()) -> active#(tt()) ->
    active#(plus(N,0())) -> U11#(isNat(N),N)
    mark#(tt()) -> active#(tt()) -> active#(plus(N,0())) -> isNat#(N)
    mark#(tt()) -> active#(tt()) ->
    active#(isNat(s(V1))) -> mark#(isNat(V1))
    mark#(tt()) -> active#(tt()) -> active#(isNat(s(V1))) -> isNat#(V1)
    mark#(tt()) -> active#(tt()) ->
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
    mark#(tt()) -> active#(tt()) ->
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2))
    mark#(tt()) -> active#(tt()) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V1)
    mark#(tt()) -> active#(tt()) ->
    active#(isNat(plus(V1,V2))) -> isNat#(V2)
    mark#(tt()) -> active#(tt()) -> active#(isNat(0())) -> mark#(tt())
    mark#(tt()) -> active#(tt()) -> active#(and(tt(),X)) -> mark#(X)
    mark#(tt()) -> active#(tt()) ->
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
    mark#(tt()) -> active#(tt()) ->
    active#(U21(tt(),M,N)) -> s#(plus(N,M))
    mark#(tt()) -> active#(tt()) ->
    active#(U21(tt(),M,N)) -> plus#(N,M)
    mark#(tt()) -> active#(tt()) ->
    active#(U11(tt(),N)) -> mark#(N)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(0()) -> active#(0())
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(s(X)) -> s#(mark(X))
    active#(isNat(0())) -> mark#(tt()) -> mark#(s(X)) -> mark#(X)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(tt()) -> active#(tt())
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(isNat(0())) -> mark#(tt()) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(isNat(s(V1))) -> isNat#(V1) ->
    isNat#(active(X)) -> isNat#(X)
    active#(isNat(s(V1))) -> isNat#(V1) ->
    isNat#(mark(X)) -> isNat#(X)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(0()) -> active#(0())
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(s(X)) -> s#(mark(X))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(s(X)) -> mark#(X)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(tt()) -> active#(tt())
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2)) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2)) ->
    and#(active(X1),X2) -> and#(X1,X2)
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2)) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2)) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    active#(isNat(plus(V1,V2))) -> isNat#(V2) ->
    isNat#(active(X)) -> isNat#(X)
    active#(isNat(plus(V1,V2))) -> isNat#(V2) ->
    isNat#(mark(X)) -> isNat#(X)
    active#(isNat(plus(V1,V2))) -> isNat#(V1) ->
    isNat#(active(X)) -> isNat#(X)
    active#(isNat(plus(V1,V2))) -> isNat#(V1) ->
    isNat#(mark(X)) -> isNat#(X)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(0()) -> active#(0())
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(s(X)) -> mark#(X)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(tt()) -> active#(tt())
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(and(tt(),X)) -> mark#(X) -> mark#(0()) -> active#(0())
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X))
    active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(tt()) -> active#(tt())
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(and(tt(),X)) -> mark#(X) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(plus(N,0())) -> U11#(isNat(N),N) ->
    U11#(X1,active(X2)) -> U11#(X1,X2)
    active#(plus(N,0())) -> U11#(isNat(N),N) ->
    U11#(active(X1),X2) -> U11#(X1,X2)
    active#(plus(N,0())) -> U11#(isNat(N),N) ->
    U11#(X1,mark(X2)) -> U11#(X1,X2)
    active#(plus(N,0())) -> U11#(isNat(N),N) ->
    U11#(mark(X1),X2) -> U11#(X1,X2)
    active#(plus(N,0())) -> isNat#(N) ->
    isNat#(active(X)) -> isNat#(X)
    active#(plus(N,0())) -> isNat#(N) ->
    isNat#(mark(X)) -> isNat#(X)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(0()) -> active#(0())
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(s(X)) -> s#(mark(X))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(s(X)) -> mark#(X)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(tt()) -> active#(tt())
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
    U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
    U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
    U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
    U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
    U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
    active#(plus(N,s(M))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
    U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N)) ->
    and#(X1,active(X2)) -> and#(X1,X2)
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N)) ->
    and#(active(X1),X2) -> and#(X1,X2)
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N)) ->
    and#(X1,mark(X2)) -> and#(X1,X2)
    active#(plus(N,s(M))) -> and#(isNat(M),isNat(N)) ->
    and#(mark(X1),X2) -> and#(X1,X2)
    active#(plus(N,s(M))) -> isNat#(N) ->
    isNat#(active(X)) -> isNat#(X)
    active#(plus(N,s(M))) -> isNat#(N) ->
    isNat#(mark(X)) -> isNat#(X)
    active#(plus(N,s(M))) -> isNat#(M) ->
    isNat#(active(X)) -> isNat#(X)
    active#(plus(N,s(M))) -> isNat#(M) ->
    isNat#(mark(X)) -> isNat#(X)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(0()) -> active#(0())
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(s(X)) -> s#(mark(X))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(s(X)) -> mark#(X)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(tt()) -> active#(tt())
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(U21(tt(),M,N)) -> s#(plus(N,M)) ->
    s#(active(X)) -> s#(X)
    active#(U21(tt(),M,N)) -> s#(plus(N,M)) ->
    s#(mark(X)) -> s#(X)
    active#(U21(tt(),M,N)) -> plus#(N,M) ->
    plus#(X1,active(X2)) -> plus#(X1,X2)
    active#(U21(tt(),M,N)) -> plus#(N,M) ->
    plus#(active(X1),X2) -> plus#(X1,X2)
    active#(U21(tt(),M,N)) -> plus#(N,M) ->
    plus#(X1,mark(X2)) -> plus#(X1,X2)
    active#(U21(tt(),M,N)) -> plus#(N,M) ->
    plus#(mark(X1),X2) -> plus#(X1,X2)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(0()) -> active#(0())
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(s(X)) -> s#(mark(X))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(s(X)) -> mark#(X)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(tt()) -> active#(tt())
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
    mark#(U11(X1,X2)) -> mark#(X1)
    active#(U11(tt(),N)) -> mark#(N) -> mark#(0()) -> active#(0())
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(isNat(X)) -> active#(isNat(X))
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(and(X1,X2)) -> and#(mark(X1),X2)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(and(X1,X2)) -> mark#(X1)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(plus(X1,X2)) -> mark#(X1)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(plus(X1,X2)) -> mark#(X2)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(s(X)) -> active#(s(mark(X)))
    active#(U11(tt(),N)) -> mark#(N) -> mark#(s(X)) -> s#(mark(X))
    active#(U11(tt(),N)) -> mark#(N) -> mark#(s(X)) -> mark#(X)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(U21(X1,X2,X3)) -> mark#(X1)
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(tt()) -> active#(tt())
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
    active#(U11(tt(),N)) -> mark#(N) ->
    mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
    active#(U11(tt(),N)) -> mark#(N) -> mark#(U11(X1,X2)) -> mark#(X1)
   SCC Processor:
    #sccs: 7
    #rules: 44
    #arcs: 574/3721
    DPs:
     mark#(isNat(X)) -> active#(isNat(X))
     active#(U11(tt(),N)) -> mark#(N)
     mark#(U11(X1,X2)) -> mark#(X1)
     mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
     active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
     mark#(tt()) -> active#(tt())
     active#(and(tt(),X)) -> mark#(X)
     mark#(U21(X1,X2,X3)) -> mark#(X1)
     mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
     active#(isNat(0())) -> mark#(tt())
     mark#(s(X)) -> mark#(X)
     mark#(s(X)) -> active#(s(mark(X)))
     active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
     mark#(plus(X1,X2)) -> mark#(X2)
     mark#(plus(X1,X2)) -> mark#(X1)
     mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
     active#(isNat(s(V1))) -> mark#(isNat(V1))
     mark#(and(X1,X2)) -> mark#(X1)
     mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
     active#(plus(N,0())) -> mark#(U11(isNat(N),N))
     mark#(0()) -> active#(0())
     active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    EDG Processor:
     DPs:
      mark#(isNat(X)) -> active#(isNat(X))
      active#(U11(tt(),N)) -> mark#(N)
      mark#(U11(X1,X2)) -> mark#(X1)
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(tt()) -> active#(tt())
      active#(and(tt(),X)) -> mark#(X)
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(isNat(0())) -> mark#(tt())
      mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> active#(s(mark(X)))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(and(X1,X2)) -> mark#(X1)
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(0()) -> active#(0())
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
     TRS:
      active(U11(tt(),N)) -> mark(N)
      active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
      active(and(tt(),X)) -> mark(X)
      active(isNat(0())) -> mark(tt())
      active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
      active(isNat(s(V1))) -> mark(isNat(V1))
      active(plus(N,0())) -> mark(U11(isNat(N),N))
      active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
      mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
      mark(tt()) -> active(tt())
      mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
      mark(s(X)) -> active(s(mark(X)))
      mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
      mark(and(X1,X2)) -> active(and(mark(X1),X2))
      mark(isNat(X)) -> active(isNat(X))
      mark(0()) -> active(0())
      U11(mark(X1),X2) -> U11(X1,X2)
      U11(X1,mark(X2)) -> U11(X1,X2)
      U11(active(X1),X2) -> U11(X1,X2)
      U11(X1,active(X2)) -> U11(X1,X2)
      U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
      U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
      U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
      U21(active(X1),X2,X3) -> U21(X1,X2,X3)
      U21(X1,active(X2),X3) -> U21(X1,X2,X3)
      U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
      s(mark(X)) -> s(X)
      s(active(X)) -> s(X)
      plus(mark(X1),X2) -> plus(X1,X2)
      plus(X1,mark(X2)) -> plus(X1,X2)
      plus(active(X1),X2) -> plus(X1,X2)
      plus(X1,active(X2)) -> plus(X1,X2)
      and(mark(X1),X2) -> and(X1,X2)
      and(X1,mark(X2)) -> and(X1,X2)
      and(active(X1),X2) -> and(X1,X2)
      and(X1,active(X2)) -> and(X1,X2)
      isNat(mark(X)) -> isNat(X)
      isNat(active(X)) -> isNat(X)
     graph:
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(U11(tt(),N)) -> mark#(N)
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(and(tt(),X)) -> mark#(X)
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(isNat(0())) -> mark#(tt())
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(isNat(X)) -> active#(isNat(X)) ->
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      mark#(and(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> mark#(X1)
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(isNat(X)) -> active#(isNat(X))
      mark#(and(X1,X2)) -> mark#(X1) ->
      mark#(0()) -> active#(0())
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(U11(tt(),N)) -> mark#(N)
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(and(tt(),X)) -> mark#(X)
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(isNat(0())) -> mark#(tt())
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      mark#(s(X)) -> mark#(X) -> mark#(U11(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      mark#(s(X)) -> mark#(X) -> mark#(tt()) -> active#(tt())
      mark#(s(X)) -> mark#(X) -> mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
      mark#(s(X)) -> mark#(X) -> mark#(plus(X1,X2)) -> mark#(X2)
      mark#(s(X)) -> mark#(X) -> mark#(plus(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> mark#(X1)
      mark#(s(X)) -> mark#(X) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      mark#(s(X)) -> mark#(X) -> mark#(isNat(X)) -> active#(isNat(X))
      mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(U11(tt(),N)) -> mark#(N)
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(and(tt(),X)) -> mark#(X)
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(isNat(0())) -> mark#(tt())
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(s(X)) -> active#(s(mark(X))) ->
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(tt()) -> active#(tt())
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      mark#(plus(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(and(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      mark#(plus(X1,X2)) -> mark#(X2) ->
      mark#(isNat(X)) -> active#(isNat(X))
      mark#(plus(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(tt()) -> active#(tt())
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      mark#(plus(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(isNat(X)) -> active#(isNat(X))
      mark#(plus(X1,X2)) -> mark#(X1) ->
      mark#(0()) -> active#(0())
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(U11(tt(),N)) -> mark#(N)
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(and(tt(),X)) -> mark#(X)
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(isNat(0())) -> mark#(tt())
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(tt()) -> active#(tt())
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      mark#(U21(X1,X2,X3)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> mark#(X1)
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(isNat(X)) -> active#(isNat(X))
      mark#(U21(X1,X2,X3)) -> mark#(X1) ->
      mark#(0()) -> active#(0())
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(U11(tt(),N)) -> mark#(N)
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(and(tt(),X)) -> mark#(X)
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(isNat(0())) -> mark#(tt())
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      mark#(U11(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      mark#(U11(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(s(X)) -> active#(s(mark(X)))
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> mark#(X1)
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(isNat(X)) -> active#(isNat(X))
      mark#(U11(X1,X2)) -> mark#(X1) ->
      mark#(0()) -> active#(0())
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(U11(tt(),N)) -> mark#(N)
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(and(tt(),X)) -> mark#(X)
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(isNat(0())) -> mark#(tt())
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      active#(isNat(0())) -> mark#(tt()) ->
      mark#(tt()) -> active#(tt())
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(s(X)) -> mark#(X)
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(s(X)) -> mark#(X)
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(tt()) -> active#(tt())
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(and(tt(),X)) -> mark#(X) ->
      mark#(0()) -> active#(0())
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(s(X)) -> mark#(X)
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(s(X)) -> mark#(X)
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(s(X)) -> mark#(X)
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(U11(X1,X2)) -> mark#(X1)
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(tt()) -> active#(tt())
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(U21(X1,X2,X3)) -> mark#(X1)
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
      active#(U11(tt(),N)) -> mark#(N) -> mark#(s(X)) -> mark#(X)
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(s(X)) -> active#(s(mark(X)))
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(plus(X1,X2)) -> mark#(X2)
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(plus(X1,X2)) -> mark#(X1)
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(and(X1,X2)) -> mark#(X1)
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
      active#(U11(tt(),N)) -> mark#(N) ->
      mark#(isNat(X)) -> active#(isNat(X))
      active#(U11(tt(),N)) -> mark#(N) -> mark#(0()) -> active#(0())
     CDG Processor:
      DPs:
       mark#(isNat(X)) -> active#(isNat(X))
       active#(U11(tt(),N)) -> mark#(N)
       mark#(U11(X1,X2)) -> mark#(X1)
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
       mark#(tt()) -> active#(tt())
       active#(and(tt(),X)) -> mark#(X)
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       active#(isNat(0())) -> mark#(tt())
       mark#(s(X)) -> mark#(X)
       mark#(s(X)) -> active#(s(mark(X)))
       active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
       mark#(plus(X1,X2)) -> mark#(X2)
       mark#(plus(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       active#(isNat(s(V1))) -> mark#(isNat(V1))
       mark#(and(X1,X2)) -> mark#(X1)
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       active#(plus(N,0())) -> mark#(U11(isNat(N),N))
       mark#(0()) -> active#(0())
       active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
      graph:
       mark#(isNat(X)) -> active#(isNat(X)) ->
       active#(isNat(s(V1))) -> mark#(isNat(V1))
       mark#(isNat(X)) -> active#(isNat(X)) ->
       active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
       mark#(isNat(X)) -> active#(isNat(X)) ->
       active#(isNat(0())) -> mark#(tt())
       mark#(and(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(isNat(X)) -> active#(isNat(X))
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> mark#(X1)
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(s(X)) -> active#(s(mark(X)))
       mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(and(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       mark#(and(X1,X2)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) ->
       active#(and(tt(),X)) -> mark#(X)
       mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0())
       mark#(s(X)) -> mark#(X) -> mark#(isNat(X)) -> active#(isNat(X))
       mark#(s(X)) -> mark#(X) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> mark#(X1)
       mark#(s(X)) -> mark#(X) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       mark#(s(X)) -> mark#(X) -> mark#(plus(X1,X2)) -> mark#(X1)
       mark#(s(X)) -> mark#(X) -> mark#(plus(X1,X2)) -> mark#(X2)
       mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X)))
       mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
       mark#(s(X)) -> mark#(X) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       mark#(s(X)) -> mark#(X) -> mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(s(X)) -> mark#(X) -> mark#(tt()) -> active#(tt())
       mark#(s(X)) -> mark#(X) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       mark#(s(X)) -> mark#(X) -> mark#(U11(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0())
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(isNat(X)) -> active#(isNat(X))
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(and(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(s(X)) -> active#(s(mark(X)))
       mark#(plus(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X)
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(tt()) -> active#(tt())
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       mark#(plus(X1,X2)) -> mark#(X2) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(isNat(X)) -> active#(isNat(X))
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(s(X)) -> active#(s(mark(X)))
       mark#(plus(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(tt()) -> active#(tt())
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       mark#(plus(X1,X2)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
       active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2))) ->
       active#(plus(N,0())) -> mark#(U11(isNat(N),N))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(0()) -> active#(0())
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(isNat(X)) -> active#(isNat(X))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> mark#(X1)
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(s(X)) -> active#(s(mark(X)))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(s(X)) -> mark#(X)
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(tt()) -> active#(tt())
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       mark#(U21(X1,X2,X3)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3)) ->
       active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
       mark#(U11(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0())
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(isNat(X)) -> active#(isNat(X))
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(and(X1,X2)) -> mark#(X1)
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(s(X)) -> active#(s(mark(X)))
       mark#(U11(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X)
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       mark#(U11(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt())
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       mark#(U11(X1,X2)) -> mark#(X1) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2)) ->
       active#(U11(tt(),N)) -> mark#(N)
       active#(isNat(0())) -> mark#(tt()) ->
       mark#(tt()) -> active#(tt())
       active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
       mark#(isNat(X)) -> active#(isNat(X))
       active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2))) ->
       mark#(and(X1,X2)) -> mark#(X1)
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(0()) -> active#(0())
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(isNat(X)) -> active#(isNat(X))
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(and(X1,X2)) -> mark#(X1)
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(s(X)) -> active#(s(mark(X)))
       active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> mark#(X)
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(tt()) -> active#(tt())
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       active#(and(tt(),X)) -> mark#(X) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       active#(plus(N,0())) -> mark#(U11(isNat(N),N)) ->
       mark#(U11(X1,X2)) -> mark#(X1)
       active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
       mark#(s(X)) -> active#(s(mark(X)))
       active#(U21(tt(),M,N)) -> mark#(s(plus(N,M))) ->
       mark#(s(X)) -> mark#(X)
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(0()) -> active#(0())
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(isNat(X)) -> active#(isNat(X))
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(and(X1,X2)) -> mark#(X1)
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(plus(X1,X2)) -> mark#(X1)
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(plus(X1,X2)) -> mark#(X2)
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(s(X)) -> active#(s(mark(X)))
       active#(U11(tt(),N)) -> mark#(N) -> mark#(s(X)) -> mark#(X)
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(U21(X1,X2,X3)) -> mark#(X1)
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(tt()) -> active#(tt())
       active#(U11(tt(),N)) -> mark#(N) ->
       mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
       active#(U11(tt(),N)) -> mark#(N) -> mark#(U11(X1,X2)) -> mark#(X1)
      SCC Processor:
       #sccs: 1
       #rules: 18
       #arcs: 130/484
       DPs:
        mark#(isNat(X)) -> active#(isNat(X))
        active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
        mark#(and(X1,X2)) -> mark#(X1)
        mark#(U11(X1,X2)) -> mark#(X1)
        mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
        active#(U11(tt(),N)) -> mark#(N)
        mark#(U21(X1,X2,X3)) -> mark#(X1)
        mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
        active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
        mark#(s(X)) -> mark#(X)
        mark#(plus(X1,X2)) -> mark#(X2)
        mark#(plus(X1,X2)) -> mark#(X1)
        mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
        active#(plus(N,0())) -> mark#(U11(isNat(N),N))
        active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
        mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
        active#(and(tt(),X)) -> mark#(X)
        active#(isNat(s(V1))) -> mark#(isNat(V1))
       TRS:
        active(U11(tt(),N)) -> mark(N)
        active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
        active(and(tt(),X)) -> mark(X)
        active(isNat(0())) -> mark(tt())
        active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
        active(isNat(s(V1))) -> mark(isNat(V1))
        active(plus(N,0())) -> mark(U11(isNat(N),N))
        active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
        mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
        mark(tt()) -> active(tt())
        mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
        mark(s(X)) -> active(s(mark(X)))
        mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
        mark(and(X1,X2)) -> active(and(mark(X1),X2))
        mark(isNat(X)) -> active(isNat(X))
        mark(0()) -> active(0())
        U11(mark(X1),X2) -> U11(X1,X2)
        U11(X1,mark(X2)) -> U11(X1,X2)
        U11(active(X1),X2) -> U11(X1,X2)
        U11(X1,active(X2)) -> U11(X1,X2)
        U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
        U21(active(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,active(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        plus(mark(X1),X2) -> plus(X1,X2)
        plus(X1,mark(X2)) -> plus(X1,X2)
        plus(active(X1),X2) -> plus(X1,X2)
        plus(X1,active(X2)) -> plus(X1,X2)
        and(mark(X1),X2) -> and(X1,X2)
        and(X1,mark(X2)) -> and(X1,X2)
        and(active(X1),X2) -> and(X1,X2)
        and(X1,active(X2)) -> and(X1,X2)
        isNat(mark(X)) -> isNat(X)
        isNat(active(X)) -> isNat(X)
       Arctic Interpretation Processor:
        dimension: 1
        interpretation:
         [mark#](x0) = x0 + 0,
         
         [active#](x0) = x0 + 0,
         
         [isNat](x0) = 6,
         
         [0] = 4,
         
         [and](x0, x1) = x0 + x1 + 0,
         
         [s](x0) = x0 + 5,
         
         [plus](x0, x1) = x0 + 2x1 + 0,
         
         [U21](x0, x1, x2) = 1x0 + 2x1 + x2 + 1,
         
         [mark](x0) = x0,
         
         [active](x0) = x0 + 0,
         
         [U11](x0, x1) = x0 + x1 + 0,
         
         [tt] = 4
        orientation:
         mark#(isNat(X)) = 6 >= 6 = active#(isNat(X))
         
         active#(isNat(plus(V1,V2))) = 6 >= 6 = mark#(and(isNat(V1),isNat(V2)))
         
         mark#(and(X1,X2)) = X1 + X2 + 0 >= X1 + 0 = mark#(X1)
         
         mark#(U11(X1,X2)) = X1 + X2 + 0 >= X1 + 0 = mark#(X1)
         
         mark#(U11(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active#(U11(mark(X1),X2))
         
         active#(U11(tt(),N)) = N + 4 >= N + 0 = mark#(N)
         
         mark#(U21(X1,X2,X3)) = 1X1 + 2X2 + X3 + 1 >= X1 + 0 = mark#(X1)
         
         mark#(U21(X1,X2,X3)) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = active#(U21(mark(X1),X2,X3))
         
         active#(U21(tt(),M,N)) = 2M + N + 5 >= 2M + N + 5 = mark#(s(plus(N,M)))
         
         mark#(s(X)) = X + 5 >= X + 0 = mark#(X)
         
         mark#(plus(X1,X2)) = X1 + 2X2 + 0 >= X2 + 0 = mark#(X2)
         
         mark#(plus(X1,X2)) = X1 + 2X2 + 0 >= X1 + 0 = mark#(X1)
         
         mark#(plus(X1,X2)) = X1 + 2X2 + 0 >= X1 + 2X2 + 0 = active#(plus(mark(X1),mark(X2)))
         
         active#(plus(N,0())) = N + 6 >= N + 6 = mark#(U11(isNat(N),N))
         
         active#(plus(N,s(M))) = 2M + N + 7 >= 2M + N + 7 = mark#(U21(and(isNat(M),isNat(N)),M,N))
         
         mark#(and(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active#(and(mark(X1),X2))
         
         active#(and(tt(),X)) = X + 4 >= X + 0 = mark#(X)
         
         active#(isNat(s(V1))) = 6 >= 6 = mark#(isNat(V1))
         
         active(U11(tt(),N)) = N + 4 >= N = mark(N)
         
         active(U21(tt(),M,N)) = 2M + N + 5 >= 2M + N + 5 = mark(s(plus(N,M)))
         
         active(and(tt(),X)) = X + 4 >= X = mark(X)
         
         active(isNat(0())) = 6 >= 4 = mark(tt())
         
         active(isNat(plus(V1,V2))) = 6 >= 6 = mark(and(isNat(V1),isNat(V2)))
         
         active(isNat(s(V1))) = 6 >= 6 = mark(isNat(V1))
         
         active(plus(N,0())) = N + 6 >= N + 6 = mark(U11(isNat(N),N))
         
         active(plus(N,s(M))) = 2M + N + 7 >= 2M + N + 7 = mark(U21(and(isNat(M),isNat(N)),M,N))
         
         mark(U11(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active(U11(mark(X1),X2))
         
         mark(tt()) = 4 >= 4 = active(tt())
         
         mark(U21(X1,X2,X3)) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = active(U21(mark(X1),X2,X3))
         
         mark(s(X)) = X + 5 >= X + 5 = active(s(mark(X)))
         
         mark(plus(X1,X2)) = X1 + 2X2 + 0 >= X1 + 2X2 + 0 = active(plus(mark(X1),mark(X2)))
         
         mark(and(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active(and(mark(X1),X2))
         
         mark(isNat(X)) = 6 >= 6 = active(isNat(X))
         
         mark(0()) = 4 >= 4 = active(0())
         
         U11(mark(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
         
         U11(X1,mark(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
         
         U11(active(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
         
         U11(X1,active(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
         
         U21(mark(X1),X2,X3) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = U21(X1,X2,X3)
         
         U21(X1,mark(X2),X3) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = U21(X1,X2,X3)
         
         U21(X1,X2,mark(X3)) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = U21(X1,X2,X3)
         
         U21(active(X1),X2,X3) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = U21(X1,X2,X3)
         
         U21(X1,active(X2),X3) = 1X1 + 2X2 + X3 + 2 >= 1X1 + 2X2 + X3 + 1 = U21(X1,X2,X3)
         
         U21(X1,X2,active(X3)) = 1X1 + 2X2 + X3 + 1 >= 1X1 + 2X2 + X3 + 1 = U21(X1,X2,X3)
         
         s(mark(X)) = X + 5 >= X + 5 = s(X)
         
         s(active(X)) = X + 5 >= X + 5 = s(X)
         
         plus(mark(X1),X2) = X1 + 2X2 + 0 >= X1 + 2X2 + 0 = plus(X1,X2)
         
         plus(X1,mark(X2)) = X1 + 2X2 + 0 >= X1 + 2X2 + 0 = plus(X1,X2)
         
         plus(active(X1),X2) = X1 + 2X2 + 0 >= X1 + 2X2 + 0 = plus(X1,X2)
         
         plus(X1,active(X2)) = X1 + 2X2 + 2 >= X1 + 2X2 + 0 = plus(X1,X2)
         
         and(mark(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
         
         and(X1,mark(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
         
         and(active(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
         
         and(X1,active(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
         
         isNat(mark(X)) = 6 >= 6 = isNat(X)
         
         isNat(active(X)) = 6 >= 6 = isNat(X)
        problem:
         DPs:
          mark#(isNat(X)) -> active#(isNat(X))
          active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
          mark#(and(X1,X2)) -> mark#(X1)
          mark#(U11(X1,X2)) -> mark#(X1)
          mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
          active#(U11(tt(),N)) -> mark#(N)
          mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
          active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
          mark#(s(X)) -> mark#(X)
          mark#(plus(X1,X2)) -> mark#(X2)
          mark#(plus(X1,X2)) -> mark#(X1)
          mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
          active#(plus(N,0())) -> mark#(U11(isNat(N),N))
          active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
          mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
          active#(and(tt(),X)) -> mark#(X)
          active#(isNat(s(V1))) -> mark#(isNat(V1))
         TRS:
          active(U11(tt(),N)) -> mark(N)
          active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
          active(and(tt(),X)) -> mark(X)
          active(isNat(0())) -> mark(tt())
          active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
          active(isNat(s(V1))) -> mark(isNat(V1))
          active(plus(N,0())) -> mark(U11(isNat(N),N))
          active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
          mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
          mark(tt()) -> active(tt())
          mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
          mark(s(X)) -> active(s(mark(X)))
          mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
          mark(and(X1,X2)) -> active(and(mark(X1),X2))
          mark(isNat(X)) -> active(isNat(X))
          mark(0()) -> active(0())
          U11(mark(X1),X2) -> U11(X1,X2)
          U11(X1,mark(X2)) -> U11(X1,X2)
          U11(active(X1),X2) -> U11(X1,X2)
          U11(X1,active(X2)) -> U11(X1,X2)
          U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
          U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
          U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
          U21(active(X1),X2,X3) -> U21(X1,X2,X3)
          U21(X1,active(X2),X3) -> U21(X1,X2,X3)
          U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
          s(mark(X)) -> s(X)
          s(active(X)) -> s(X)
          plus(mark(X1),X2) -> plus(X1,X2)
          plus(X1,mark(X2)) -> plus(X1,X2)
          plus(active(X1),X2) -> plus(X1,X2)
          plus(X1,active(X2)) -> plus(X1,X2)
          and(mark(X1),X2) -> and(X1,X2)
          and(X1,mark(X2)) -> and(X1,X2)
          and(active(X1),X2) -> and(X1,X2)
          and(X1,active(X2)) -> and(X1,X2)
          isNat(mark(X)) -> isNat(X)
          isNat(active(X)) -> isNat(X)
        Arctic Interpretation Processor:
         dimension: 1
         interpretation:
          [mark#](x0) = x0 + 0,
          
          [active#](x0) = x0 + 0,
          
          [isNat](x0) = 0,
          
          [0] = 6,
          
          [and](x0, x1) = x0 + x1 + 0,
          
          [s](x0) = x0 + 5,
          
          [plus](x0, x1) = 1x0 + 1x1 + 1,
          
          [U21](x0, x1, x2) = 6x0 + 1x1 + 1x2 + 6,
          
          [mark](x0) = x0 + 0,
          
          [active](x0) = x0,
          
          [U11](x0, x1) = x0 + x1,
          
          [tt] = 0
         orientation:
          mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
          
          active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
          
          mark#(and(X1,X2)) = X1 + X2 + 0 >= X1 + 0 = mark#(X1)
          
          mark#(U11(X1,X2)) = X1 + X2 + 0 >= X1 + 0 = mark#(X1)
          
          mark#(U11(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active#(U11(mark(X1),X2))
          
          active#(U11(tt(),N)) = N + 0 >= N + 0 = mark#(N)
          
          mark#(U21(X1,X2,X3)) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = active#(U21(mark(X1),X2,X3))
          
          active#(U21(tt(),M,N)) = 1M + 1N + 6 >= 1M + 1N + 5 = mark#(s(plus(N,M)))
          
          mark#(s(X)) = X + 5 >= X + 0 = mark#(X)
          
          mark#(plus(X1,X2)) = 1X1 + 1X2 + 1 >= X2 + 0 = mark#(X2)
          
          mark#(plus(X1,X2)) = 1X1 + 1X2 + 1 >= X1 + 0 = mark#(X1)
          
          mark#(plus(X1,X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = active#(plus(mark(X1),mark(X2)))
          
          active#(plus(N,0())) = 1N + 7 >= N + 0 = mark#(U11(isNat(N),N))
          
          active#(plus(N,s(M))) = 1M + 1N + 6 >= 1M + 1N + 6 = mark#(U21(and(isNat(M),isNat(N)),M,N))
          
          mark#(and(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active#(and(mark(X1),X2))
          
          active#(and(tt(),X)) = X + 0 >= X + 0 = mark#(X)
          
          active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
          
          active(U11(tt(),N)) = N + 0 >= N + 0 = mark(N)
          
          active(U21(tt(),M,N)) = 1M + 1N + 6 >= 1M + 1N + 5 = mark(s(plus(N,M)))
          
          active(and(tt(),X)) = X + 0 >= X + 0 = mark(X)
          
          active(isNat(0())) = 0 >= 0 = mark(tt())
          
          active(isNat(plus(V1,V2))) = 0 >= 0 = mark(and(isNat(V1),isNat(V2)))
          
          active(isNat(s(V1))) = 0 >= 0 = mark(isNat(V1))
          
          active(plus(N,0())) = 1N + 7 >= N + 0 = mark(U11(isNat(N),N))
          
          active(plus(N,s(M))) = 1M + 1N + 6 >= 1M + 1N + 6 = mark(U21(and(isNat(M),isNat(N)),M,N))
          
          mark(U11(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active(U11(mark(X1),X2))
          
          mark(tt()) = 0 >= 0 = active(tt())
          
          mark(U21(X1,X2,X3)) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = active(U21(mark(X1),X2,X3))
          
          mark(s(X)) = X + 5 >= X + 5 = active(s(mark(X)))
          
          mark(plus(X1,X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = active(plus(mark(X1),mark(X2)))
          
          mark(and(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active(and(mark(X1),X2))
          
          mark(isNat(X)) = 0 >= 0 = active(isNat(X))
          
          mark(0()) = 6 >= 6 = active(0())
          
          U11(mark(X1),X2) = X1 + X2 + 0 >= X1 + X2 = U11(X1,X2)
          
          U11(X1,mark(X2)) = X1 + X2 + 0 >= X1 + X2 = U11(X1,X2)
          
          U11(active(X1),X2) = X1 + X2 >= X1 + X2 = U11(X1,X2)
          
          U11(X1,active(X2)) = X1 + X2 >= X1 + X2 = U11(X1,X2)
          
          U21(mark(X1),X2,X3) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = U21(X1,X2,X3)
          
          U21(X1,mark(X2),X3) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = U21(X1,X2,X3)
          
          U21(X1,X2,mark(X3)) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = U21(X1,X2,X3)
          
          U21(active(X1),X2,X3) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = U21(X1,X2,X3)
          
          U21(X1,active(X2),X3) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = U21(X1,X2,X3)
          
          U21(X1,X2,active(X3)) = 6X1 + 1X2 + 1X3 + 6 >= 6X1 + 1X2 + 1X3 + 6 = U21(X1,X2,X3)
          
          s(mark(X)) = X + 5 >= X + 5 = s(X)
          
          s(active(X)) = X + 5 >= X + 5 = s(X)
          
          plus(mark(X1),X2) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = plus(X1,X2)
          
          plus(X1,mark(X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = plus(X1,X2)
          
          plus(active(X1),X2) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = plus(X1,X2)
          
          plus(X1,active(X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = plus(X1,X2)
          
          and(mark(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
          
          and(X1,mark(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
          
          and(active(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
          
          and(X1,active(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = and(X1,X2)
          
          isNat(mark(X)) = 0 >= 0 = isNat(X)
          
          isNat(active(X)) = 0 >= 0 = isNat(X)
         problem:
          DPs:
           mark#(isNat(X)) -> active#(isNat(X))
           active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
           mark#(and(X1,X2)) -> mark#(X1)
           mark#(U11(X1,X2)) -> mark#(X1)
           mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
           active#(U11(tt(),N)) -> mark#(N)
           mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
           active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
           mark#(s(X)) -> mark#(X)
           mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
           active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
           mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
           active#(and(tt(),X)) -> mark#(X)
           active#(isNat(s(V1))) -> mark#(isNat(V1))
          TRS:
           active(U11(tt(),N)) -> mark(N)
           active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
           active(and(tt(),X)) -> mark(X)
           active(isNat(0())) -> mark(tt())
           active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
           active(isNat(s(V1))) -> mark(isNat(V1))
           active(plus(N,0())) -> mark(U11(isNat(N),N))
           active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
           mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
           mark(tt()) -> active(tt())
           mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
           mark(s(X)) -> active(s(mark(X)))
           mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
           mark(and(X1,X2)) -> active(and(mark(X1),X2))
           mark(isNat(X)) -> active(isNat(X))
           mark(0()) -> active(0())
           U11(mark(X1),X2) -> U11(X1,X2)
           U11(X1,mark(X2)) -> U11(X1,X2)
           U11(active(X1),X2) -> U11(X1,X2)
           U11(X1,active(X2)) -> U11(X1,X2)
           U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
           U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
           U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
           U21(active(X1),X2,X3) -> U21(X1,X2,X3)
           U21(X1,active(X2),X3) -> U21(X1,X2,X3)
           U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
           s(mark(X)) -> s(X)
           s(active(X)) -> s(X)
           plus(mark(X1),X2) -> plus(X1,X2)
           plus(X1,mark(X2)) -> plus(X1,X2)
           plus(active(X1),X2) -> plus(X1,X2)
           plus(X1,active(X2)) -> plus(X1,X2)
           and(mark(X1),X2) -> and(X1,X2)
           and(X1,mark(X2)) -> and(X1,X2)
           and(active(X1),X2) -> and(X1,X2)
           and(X1,active(X2)) -> and(X1,X2)
           isNat(mark(X)) -> isNat(X)
           isNat(active(X)) -> isNat(X)
         Arctic Interpretation Processor:
          dimension: 1
          interpretation:
           [mark#](x0) = x0,
           
           [active#](x0) = x0,
           
           [isNat](x0) = x0,
           
           [0] = 4,
           
           [and](x0, x1) = x0 + 1x1,
           
           [s](x0) = x0 + 2,
           
           [plus](x0, x1) = x0 + 1x1,
           
           [U21](x0, x1, x2) = 1x1 + x2 + 3,
           
           [mark](x0) = x0,
           
           [active](x0) = x0,
           
           [U11](x0, x1) = x0 + x1 + 0,
           
           [tt] = 4
          orientation:
           mark#(isNat(X)) = X >= X = active#(isNat(X))
           
           active#(isNat(plus(V1,V2))) = V1 + 1V2 >= V1 + 1V2 = mark#(and(isNat(V1),isNat(V2)))
           
           mark#(and(X1,X2)) = X1 + 1X2 >= X1 = mark#(X1)
           
           mark#(U11(X1,X2)) = X1 + X2 + 0 >= X1 = mark#(X1)
           
           mark#(U11(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active#(U11(mark(X1),X2))
           
           active#(U11(tt(),N)) = N + 4 >= N = mark#(N)
           
           mark#(U21(X1,X2,X3)) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = active#(U21(mark(X1),X2,X3))
           
           active#(U21(tt(),M,N)) = 1M + N + 3 >= 1M + N + 2 = mark#(s(plus(N,M)))
           
           mark#(s(X)) = X + 2 >= X = mark#(X)
           
           mark#(plus(X1,X2)) = X1 + 1X2 >= X1 + 1X2 = active#(plus(mark(X1),mark(X2)))
           
           active#(plus(N,s(M))) = 1M + N + 3 >= 1M + N + 3 = mark#(U21(and(isNat(M),isNat(N)),M,N))
           
           mark#(and(X1,X2)) = X1 + 1X2 >= X1 + 1X2 = active#(and(mark(X1),X2))
           
           active#(and(tt(),X)) = 1X + 4 >= X = mark#(X)
           
           active#(isNat(s(V1))) = V1 + 2 >= V1 = mark#(isNat(V1))
           
           active(U11(tt(),N)) = N + 4 >= N = mark(N)
           
           active(U21(tt(),M,N)) = 1M + N + 3 >= 1M + N + 2 = mark(s(plus(N,M)))
           
           active(and(tt(),X)) = 1X + 4 >= X = mark(X)
           
           active(isNat(0())) = 4 >= 4 = mark(tt())
           
           active(isNat(plus(V1,V2))) = V1 + 1V2 >= V1 + 1V2 = mark(and(isNat(V1),isNat(V2)))
           
           active(isNat(s(V1))) = V1 + 2 >= V1 = mark(isNat(V1))
           
           active(plus(N,0())) = N + 5 >= N + 0 = mark(U11(isNat(N),N))
           
           active(plus(N,s(M))) = 1M + N + 3 >= 1M + N + 3 = mark(U21(and(isNat(M),isNat(N)),M,N))
           
           mark(U11(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = active(U11(mark(X1),X2))
           
           mark(tt()) = 4 >= 4 = active(tt())
           
           mark(U21(X1,X2,X3)) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = active(U21(mark(X1),X2,X3))
           
           mark(s(X)) = X + 2 >= X + 2 = active(s(mark(X)))
           
           mark(plus(X1,X2)) = X1 + 1X2 >= X1 + 1X2 = active(plus(mark(X1),mark(X2)))
           
           mark(and(X1,X2)) = X1 + 1X2 >= X1 + 1X2 = active(and(mark(X1),X2))
           
           mark(isNat(X)) = X >= X = active(isNat(X))
           
           mark(0()) = 4 >= 4 = active(0())
           
           U11(mark(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
           
           U11(X1,mark(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
           
           U11(active(X1),X2) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
           
           U11(X1,active(X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = U11(X1,X2)
           
           U21(mark(X1),X2,X3) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = U21(X1,X2,X3)
           
           U21(X1,mark(X2),X3) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = U21(X1,X2,X3)
           
           U21(X1,X2,mark(X3)) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = U21(X1,X2,X3)
           
           U21(active(X1),X2,X3) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = U21(X1,X2,X3)
           
           U21(X1,active(X2),X3) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = U21(X1,X2,X3)
           
           U21(X1,X2,active(X3)) = 1X2 + X3 + 3 >= 1X2 + X3 + 3 = U21(X1,X2,X3)
           
           s(mark(X)) = X + 2 >= X + 2 = s(X)
           
           s(active(X)) = X + 2 >= X + 2 = s(X)
           
           plus(mark(X1),X2) = X1 + 1X2 >= X1 + 1X2 = plus(X1,X2)
           
           plus(X1,mark(X2)) = X1 + 1X2 >= X1 + 1X2 = plus(X1,X2)
           
           plus(active(X1),X2) = X1 + 1X2 >= X1 + 1X2 = plus(X1,X2)
           
           plus(X1,active(X2)) = X1 + 1X2 >= X1 + 1X2 = plus(X1,X2)
           
           and(mark(X1),X2) = X1 + 1X2 >= X1 + 1X2 = and(X1,X2)
           
           and(X1,mark(X2)) = X1 + 1X2 >= X1 + 1X2 = and(X1,X2)
           
           and(active(X1),X2) = X1 + 1X2 >= X1 + 1X2 = and(X1,X2)
           
           and(X1,active(X2)) = X1 + 1X2 >= X1 + 1X2 = and(X1,X2)
           
           isNat(mark(X)) = X >= X = isNat(X)
           
           isNat(active(X)) = X >= X = isNat(X)
          problem:
           DPs:
            mark#(isNat(X)) -> active#(isNat(X))
            active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
            mark#(and(X1,X2)) -> mark#(X1)
            mark#(U11(X1,X2)) -> mark#(X1)
            mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
            active#(U11(tt(),N)) -> mark#(N)
            mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
            active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
            mark#(s(X)) -> mark#(X)
            mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
            active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
            mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
            active#(isNat(s(V1))) -> mark#(isNat(V1))
           TRS:
            active(U11(tt(),N)) -> mark(N)
            active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
            active(and(tt(),X)) -> mark(X)
            active(isNat(0())) -> mark(tt())
            active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
            active(isNat(s(V1))) -> mark(isNat(V1))
            active(plus(N,0())) -> mark(U11(isNat(N),N))
            active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
            mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
            mark(tt()) -> active(tt())
            mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
            mark(s(X)) -> active(s(mark(X)))
            mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
            mark(and(X1,X2)) -> active(and(mark(X1),X2))
            mark(isNat(X)) -> active(isNat(X))
            mark(0()) -> active(0())
            U11(mark(X1),X2) -> U11(X1,X2)
            U11(X1,mark(X2)) -> U11(X1,X2)
            U11(active(X1),X2) -> U11(X1,X2)
            U11(X1,active(X2)) -> U11(X1,X2)
            U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
            U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
            U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
            U21(active(X1),X2,X3) -> U21(X1,X2,X3)
            U21(X1,active(X2),X3) -> U21(X1,X2,X3)
            U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
            s(mark(X)) -> s(X)
            s(active(X)) -> s(X)
            plus(mark(X1),X2) -> plus(X1,X2)
            plus(X1,mark(X2)) -> plus(X1,X2)
            plus(active(X1),X2) -> plus(X1,X2)
            plus(X1,active(X2)) -> plus(X1,X2)
            and(mark(X1),X2) -> and(X1,X2)
            and(X1,mark(X2)) -> and(X1,X2)
            and(active(X1),X2) -> and(X1,X2)
            and(X1,active(X2)) -> and(X1,X2)
            isNat(mark(X)) -> isNat(X)
            isNat(active(X)) -> isNat(X)
          SCC Processor:
           #sccs: 1
           #rules: 12
           #arcs: 103/169
           DPs:
            mark#(isNat(X)) -> active#(isNat(X))
            active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
            mark#(and(X1,X2)) -> mark#(X1)
            mark#(U11(X1,X2)) -> mark#(X1)
            mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
            active#(U11(tt(),N)) -> mark#(N)
            mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
            active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
            mark#(s(X)) -> mark#(X)
            mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
            active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
            active#(isNat(s(V1))) -> mark#(isNat(V1))
           TRS:
            active(U11(tt(),N)) -> mark(N)
            active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
            active(and(tt(),X)) -> mark(X)
            active(isNat(0())) -> mark(tt())
            active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
            active(isNat(s(V1))) -> mark(isNat(V1))
            active(plus(N,0())) -> mark(U11(isNat(N),N))
            active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
            mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
            mark(tt()) -> active(tt())
            mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
            mark(s(X)) -> active(s(mark(X)))
            mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
            mark(and(X1,X2)) -> active(and(mark(X1),X2))
            mark(isNat(X)) -> active(isNat(X))
            mark(0()) -> active(0())
            U11(mark(X1),X2) -> U11(X1,X2)
            U11(X1,mark(X2)) -> U11(X1,X2)
            U11(active(X1),X2) -> U11(X1,X2)
            U11(X1,active(X2)) -> U11(X1,X2)
            U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
            U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
            U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
            U21(active(X1),X2,X3) -> U21(X1,X2,X3)
            U21(X1,active(X2),X3) -> U21(X1,X2,X3)
            U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
            s(mark(X)) -> s(X)
            s(active(X)) -> s(X)
            plus(mark(X1),X2) -> plus(X1,X2)
            plus(X1,mark(X2)) -> plus(X1,X2)
            plus(active(X1),X2) -> plus(X1,X2)
            plus(X1,active(X2)) -> plus(X1,X2)
            and(mark(X1),X2) -> and(X1,X2)
            and(X1,mark(X2)) -> and(X1,X2)
            and(active(X1),X2) -> and(X1,X2)
            and(X1,active(X2)) -> and(X1,X2)
            isNat(mark(X)) -> isNat(X)
            isNat(active(X)) -> isNat(X)
           Arctic Interpretation Processor:
            dimension: 1
            interpretation:
             [mark#](x0) = x0 + 0,
             
             [active#](x0) = x0 + 0,
             
             [isNat](x0) = 1x0 + 0,
             
             [0] = 1,
             
             [and](x0, x1) = 1x0 + 1x1 + 1,
             
             [s](x0) = x0 + 0,
             
             [plus](x0, x1) = 2x0 + 3x1 + 0,
             
             [U21](x0, x1, x2) = x0 + 3x1 + 2x2,
             
             [mark](x0) = x0,
             
             [active](x0) = x0,
             
             [U11](x0, x1) = x0 + 2x1,
             
             [tt] = 0
            orientation:
             mark#(isNat(X)) = 1X + 0 >= 1X + 0 = active#(isNat(X))
             
             active#(isNat(plus(V1,V2))) = 3V1 + 4V2 + 1 >= 2V1 + 2V2 + 1 = mark#(and(isNat(V1),isNat(V2)))
             
             mark#(and(X1,X2)) = 1X1 + 1X2 + 1 >= X1 + 0 = mark#(X1)
             
             mark#(U11(X1,X2)) = X1 + 2X2 + 0 >= X1 + 0 = mark#(X1)
             
             mark#(U11(X1,X2)) = X1 + 2X2 + 0 >= X1 + 2X2 + 0 = active#(U11(mark(X1),X2))
             
             active#(U11(tt(),N)) = 2N + 0 >= N + 0 = mark#(N)
             
             mark#(U21(X1,X2,X3)) = X1 + 3X2 + 2X3 + 0 >= X1 + 3X2 + 2X3 + 0 = active#(U21(mark(X1),X2,X3))
             
             active#(U21(tt(),M,N)) = 3M + 2N + 0 >= 3M + 2N + 0 = mark#(s(plus(N,M)))
             
             mark#(s(X)) = X + 0 >= X + 0 = mark#(X)
             
             mark#(plus(X1,X2)) = 2X1 + 3X2 + 0 >= 2X1 + 3X2 + 0 = active#(plus(mark(X1),mark(X2)))
             
             active#(plus(N,s(M))) = 3M + 2N + 3 >= 3M + 2N + 1 = mark#(U21(and(isNat(M),isNat(N)),M,N))
             
             active#(isNat(s(V1))) = 1V1 + 1 >= 1V1 + 0 = mark#(isNat(V1))
             
             active(U11(tt(),N)) = 2N + 0 >= N = mark(N)
             
             active(U21(tt(),M,N)) = 3M + 2N + 0 >= 3M + 2N + 0 = mark(s(plus(N,M)))
             
             active(and(tt(),X)) = 1X + 1 >= X = mark(X)
             
             active(isNat(0())) = 2 >= 0 = mark(tt())
             
             active(isNat(plus(V1,V2))) = 3V1 + 4V2 + 1 >= 2V1 + 2V2 + 1 = mark(and(isNat(V1),isNat(V2)))
             
             active(isNat(s(V1))) = 1V1 + 1 >= 1V1 + 0 = mark(isNat(V1))
             
             active(plus(N,0())) = 2N + 4 >= 2N + 0 = mark(U11(isNat(N),N))
             
             active(plus(N,s(M))) = 3M + 2N + 3 >= 3M + 2N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
             
             mark(U11(X1,X2)) = X1 + 2X2 >= X1 + 2X2 = active(U11(mark(X1),X2))
             
             mark(tt()) = 0 >= 0 = active(tt())
             
             mark(U21(X1,X2,X3)) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = active(U21(mark(X1),X2,X3))
             
             mark(s(X)) = X + 0 >= X + 0 = active(s(mark(X)))
             
             mark(plus(X1,X2)) = 2X1 + 3X2 + 0 >= 2X1 + 3X2 + 0 = active(plus(mark(X1),mark(X2)))
             
             mark(and(X1,X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = active(and(mark(X1),X2))
             
             mark(isNat(X)) = 1X + 0 >= 1X + 0 = active(isNat(X))
             
             mark(0()) = 1 >= 1 = active(0())
             
             U11(mark(X1),X2) = X1 + 2X2 >= X1 + 2X2 = U11(X1,X2)
             
             U11(X1,mark(X2)) = X1 + 2X2 >= X1 + 2X2 = U11(X1,X2)
             
             U11(active(X1),X2) = X1 + 2X2 >= X1 + 2X2 = U11(X1,X2)
             
             U11(X1,active(X2)) = X1 + 2X2 >= X1 + 2X2 = U11(X1,X2)
             
             U21(mark(X1),X2,X3) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = U21(X1,X2,X3)
             
             U21(X1,mark(X2),X3) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = U21(X1,X2,X3)
             
             U21(X1,X2,mark(X3)) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = U21(X1,X2,X3)
             
             U21(active(X1),X2,X3) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = U21(X1,X2,X3)
             
             U21(X1,active(X2),X3) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = U21(X1,X2,X3)
             
             U21(X1,X2,active(X3)) = X1 + 3X2 + 2X3 >= X1 + 3X2 + 2X3 = U21(X1,X2,X3)
             
             s(mark(X)) = X + 0 >= X + 0 = s(X)
             
             s(active(X)) = X + 0 >= X + 0 = s(X)
             
             plus(mark(X1),X2) = 2X1 + 3X2 + 0 >= 2X1 + 3X2 + 0 = plus(X1,X2)
             
             plus(X1,mark(X2)) = 2X1 + 3X2 + 0 >= 2X1 + 3X2 + 0 = plus(X1,X2)
             
             plus(active(X1),X2) = 2X1 + 3X2 + 0 >= 2X1 + 3X2 + 0 = plus(X1,X2)
             
             plus(X1,active(X2)) = 2X1 + 3X2 + 0 >= 2X1 + 3X2 + 0 = plus(X1,X2)
             
             and(mark(X1),X2) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = and(X1,X2)
             
             and(X1,mark(X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = and(X1,X2)
             
             and(active(X1),X2) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = and(X1,X2)
             
             and(X1,active(X2)) = 1X1 + 1X2 + 1 >= 1X1 + 1X2 + 1 = and(X1,X2)
             
             isNat(mark(X)) = 1X + 0 >= 1X + 0 = isNat(X)
             
             isNat(active(X)) = 1X + 0 >= 1X + 0 = isNat(X)
            problem:
             DPs:
              mark#(isNat(X)) -> active#(isNat(X))
              active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
              mark#(U11(X1,X2)) -> mark#(X1)
              mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
              active#(U11(tt(),N)) -> mark#(N)
              mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
              active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
              mark#(s(X)) -> mark#(X)
              mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
              active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
              active#(isNat(s(V1))) -> mark#(isNat(V1))
             TRS:
              active(U11(tt(),N)) -> mark(N)
              active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
              active(and(tt(),X)) -> mark(X)
              active(isNat(0())) -> mark(tt())
              active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
              active(isNat(s(V1))) -> mark(isNat(V1))
              active(plus(N,0())) -> mark(U11(isNat(N),N))
              active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
              mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
              mark(tt()) -> active(tt())
              mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
              mark(s(X)) -> active(s(mark(X)))
              mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
              mark(and(X1,X2)) -> active(and(mark(X1),X2))
              mark(isNat(X)) -> active(isNat(X))
              mark(0()) -> active(0())
              U11(mark(X1),X2) -> U11(X1,X2)
              U11(X1,mark(X2)) -> U11(X1,X2)
              U11(active(X1),X2) -> U11(X1,X2)
              U11(X1,active(X2)) -> U11(X1,X2)
              U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
              U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
              U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
              U21(active(X1),X2,X3) -> U21(X1,X2,X3)
              U21(X1,active(X2),X3) -> U21(X1,X2,X3)
              U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
              s(mark(X)) -> s(X)
              s(active(X)) -> s(X)
              plus(mark(X1),X2) -> plus(X1,X2)
              plus(X1,mark(X2)) -> plus(X1,X2)
              plus(active(X1),X2) -> plus(X1,X2)
              plus(X1,active(X2)) -> plus(X1,X2)
              and(mark(X1),X2) -> and(X1,X2)
              and(X1,mark(X2)) -> and(X1,X2)
              and(active(X1),X2) -> and(X1,X2)
              and(X1,active(X2)) -> and(X1,X2)
              isNat(mark(X)) -> isNat(X)
              isNat(active(X)) -> isNat(X)
            SCC Processor:
             #sccs: 2
             #rules: 10
             #arcs: 37/121
             DPs:
              mark#(s(X)) -> mark#(X)
              mark#(U11(X1,X2)) -> mark#(X1)
              mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
              active#(U11(tt(),N)) -> mark#(N)
              mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
              active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
              mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
              active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
             TRS:
              active(U11(tt(),N)) -> mark(N)
              active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
              active(and(tt(),X)) -> mark(X)
              active(isNat(0())) -> mark(tt())
              active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
              active(isNat(s(V1))) -> mark(isNat(V1))
              active(plus(N,0())) -> mark(U11(isNat(N),N))
              active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
              mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
              mark(tt()) -> active(tt())
              mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
              mark(s(X)) -> active(s(mark(X)))
              mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
              mark(and(X1,X2)) -> active(and(mark(X1),X2))
              mark(isNat(X)) -> active(isNat(X))
              mark(0()) -> active(0())
              U11(mark(X1),X2) -> U11(X1,X2)
              U11(X1,mark(X2)) -> U11(X1,X2)
              U11(active(X1),X2) -> U11(X1,X2)
              U11(X1,active(X2)) -> U11(X1,X2)
              U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
              U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
              U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
              U21(active(X1),X2,X3) -> U21(X1,X2,X3)
              U21(X1,active(X2),X3) -> U21(X1,X2,X3)
              U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
              s(mark(X)) -> s(X)
              s(active(X)) -> s(X)
              plus(mark(X1),X2) -> plus(X1,X2)
              plus(X1,mark(X2)) -> plus(X1,X2)
              plus(active(X1),X2) -> plus(X1,X2)
              plus(X1,active(X2)) -> plus(X1,X2)
              and(mark(X1),X2) -> and(X1,X2)
              and(X1,mark(X2)) -> and(X1,X2)
              and(active(X1),X2) -> and(X1,X2)
              and(X1,active(X2)) -> and(X1,X2)
              isNat(mark(X)) -> isNat(X)
              isNat(active(X)) -> isNat(X)
             Arctic Interpretation Processor:
              dimension: 1
              interpretation:
               [mark#](x0) = x0,
               
               [active#](x0) = x0 + 0,
               
               [isNat](x0) = 2x0 + 1,
               
               [0] = 0,
               
               [and](x0, x1) = x0 + x1 + 3,
               
               [s](x0) = x0,
               
               [plus](x0, x1) = 3x0 + 4x1 + 1,
               
               [U21](x0, x1, x2) = 4x1 + 3x2 + 1,
               
               [mark](x0) = x0,
               
               [active](x0) = x0,
               
               [U11](x0, x1) = x0 + 1x1 + 0,
               
               [tt] = 0
              orientation:
               mark#(s(X)) = X >= X = mark#(X)
               
               mark#(U11(X1,X2)) = X1 + 1X2 + 0 >= X1 = mark#(X1)
               
               mark#(U11(X1,X2)) = X1 + 1X2 + 0 >= X1 + 1X2 + 0 = active#(U11(mark(X1),X2))
               
               active#(U11(tt(),N)) = 1N + 0 >= N = mark#(N)
               
               mark#(U21(X1,X2,X3)) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = active#(U21(mark(X1),X2,X3))
               
               active#(U21(tt(),M,N)) = 4M + 3N + 1 >= 4M + 3N + 1 = mark#(s(plus(N,M)))
               
               mark#(plus(X1,X2)) = 3X1 + 4X2 + 1 >= 3X1 + 4X2 + 1 = active#(plus(mark(X1),mark(X2)))
               
               active#(plus(N,s(M))) = 4M + 3N + 1 >= 4M + 3N + 1 = mark#(U21(and(isNat(M),isNat(N)),M,N))
               
               active(U11(tt(),N)) = 1N + 0 >= N = mark(N)
               
               active(U21(tt(),M,N)) = 4M + 3N + 1 >= 4M + 3N + 1 = mark(s(plus(N,M)))
               
               active(and(tt(),X)) = X + 3 >= X = mark(X)
               
               active(isNat(0())) = 2 >= 0 = mark(tt())
               
               active(isNat(plus(V1,V2))) = 5V1 + 6V2 + 3 >= 2V1 + 2V2 + 3 = mark(and(isNat(V1),isNat(V2)))
               
               active(isNat(s(V1))) = 2V1 + 1 >= 2V1 + 1 = mark(isNat(V1))
               
               active(plus(N,0())) = 3N + 4 >= 2N + 1 = mark(U11(isNat(N),N))
               
               active(plus(N,s(M))) = 4M + 3N + 1 >= 4M + 3N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
               
               mark(U11(X1,X2)) = X1 + 1X2 + 0 >= X1 + 1X2 + 0 = active(U11(mark(X1),X2))
               
               mark(tt()) = 0 >= 0 = active(tt())
               
               mark(U21(X1,X2,X3)) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = active(U21(mark(X1),X2,X3))
               
               mark(s(X)) = X >= X = active(s(mark(X)))
               
               mark(plus(X1,X2)) = 3X1 + 4X2 + 1 >= 3X1 + 4X2 + 1 = active(plus(mark(X1),mark(X2)))
               
               mark(and(X1,X2)) = X1 + X2 + 3 >= X1 + X2 + 3 = active(and(mark(X1),X2))
               
               mark(isNat(X)) = 2X + 1 >= 2X + 1 = active(isNat(X))
               
               mark(0()) = 0 >= 0 = active(0())
               
               U11(mark(X1),X2) = X1 + 1X2 + 0 >= X1 + 1X2 + 0 = U11(X1,X2)
               
               U11(X1,mark(X2)) = X1 + 1X2 + 0 >= X1 + 1X2 + 0 = U11(X1,X2)
               
               U11(active(X1),X2) = X1 + 1X2 + 0 >= X1 + 1X2 + 0 = U11(X1,X2)
               
               U11(X1,active(X2)) = X1 + 1X2 + 0 >= X1 + 1X2 + 0 = U11(X1,X2)
               
               U21(mark(X1),X2,X3) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,mark(X2),X3) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,X2,mark(X3)) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = U21(X1,X2,X3)
               
               U21(active(X1),X2,X3) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,active(X2),X3) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,X2,active(X3)) = 4X2 + 3X3 + 1 >= 4X2 + 3X3 + 1 = U21(X1,X2,X3)
               
               s(mark(X)) = X >= X = s(X)
               
               s(active(X)) = X >= X = s(X)
               
               plus(mark(X1),X2) = 3X1 + 4X2 + 1 >= 3X1 + 4X2 + 1 = plus(X1,X2)
               
               plus(X1,mark(X2)) = 3X1 + 4X2 + 1 >= 3X1 + 4X2 + 1 = plus(X1,X2)
               
               plus(active(X1),X2) = 3X1 + 4X2 + 1 >= 3X1 + 4X2 + 1 = plus(X1,X2)
               
               plus(X1,active(X2)) = 3X1 + 4X2 + 1 >= 3X1 + 4X2 + 1 = plus(X1,X2)
               
               and(mark(X1),X2) = X1 + X2 + 3 >= X1 + X2 + 3 = and(X1,X2)
               
               and(X1,mark(X2)) = X1 + X2 + 3 >= X1 + X2 + 3 = and(X1,X2)
               
               and(active(X1),X2) = X1 + X2 + 3 >= X1 + X2 + 3 = and(X1,X2)
               
               and(X1,active(X2)) = X1 + X2 + 3 >= X1 + X2 + 3 = and(X1,X2)
               
               isNat(mark(X)) = 2X + 1 >= 2X + 1 = isNat(X)
               
               isNat(active(X)) = 2X + 1 >= 2X + 1 = isNat(X)
              problem:
               DPs:
                mark#(s(X)) -> mark#(X)
                mark#(U11(X1,X2)) -> mark#(X1)
                mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
                mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
                active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
                mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
                active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
               TRS:
                active(U11(tt(),N)) -> mark(N)
                active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
                active(and(tt(),X)) -> mark(X)
                active(isNat(0())) -> mark(tt())
                active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
                active(isNat(s(V1))) -> mark(isNat(V1))
                active(plus(N,0())) -> mark(U11(isNat(N),N))
                active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
                mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
                mark(tt()) -> active(tt())
                mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
                mark(s(X)) -> active(s(mark(X)))
                mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
                mark(and(X1,X2)) -> active(and(mark(X1),X2))
                mark(isNat(X)) -> active(isNat(X))
                mark(0()) -> active(0())
                U11(mark(X1),X2) -> U11(X1,X2)
                U11(X1,mark(X2)) -> U11(X1,X2)
                U11(active(X1),X2) -> U11(X1,X2)
                U11(X1,active(X2)) -> U11(X1,X2)
                U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
                U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
                U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
                U21(active(X1),X2,X3) -> U21(X1,X2,X3)
                U21(X1,active(X2),X3) -> U21(X1,X2,X3)
                U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
                s(mark(X)) -> s(X)
                s(active(X)) -> s(X)
                plus(mark(X1),X2) -> plus(X1,X2)
                plus(X1,mark(X2)) -> plus(X1,X2)
                plus(active(X1),X2) -> plus(X1,X2)
                plus(X1,active(X2)) -> plus(X1,X2)
                and(mark(X1),X2) -> and(X1,X2)
                and(X1,mark(X2)) -> and(X1,X2)
                and(active(X1),X2) -> and(X1,X2)
                and(X1,active(X2)) -> and(X1,X2)
                isNat(mark(X)) -> isNat(X)
                isNat(active(X)) -> isNat(X)
              SCC Processor:
               #sccs: 1
               #rules: 6
               #arcs: 20/49
               DPs:
                mark#(s(X)) -> mark#(X)
                mark#(U11(X1,X2)) -> mark#(X1)
                mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
                active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
                mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
                active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
               TRS:
                active(U11(tt(),N)) -> mark(N)
                active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
                active(and(tt(),X)) -> mark(X)
                active(isNat(0())) -> mark(tt())
                active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
                active(isNat(s(V1))) -> mark(isNat(V1))
                active(plus(N,0())) -> mark(U11(isNat(N),N))
                active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
                mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
                mark(tt()) -> active(tt())
                mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
                mark(s(X)) -> active(s(mark(X)))
                mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
                mark(and(X1,X2)) -> active(and(mark(X1),X2))
                mark(isNat(X)) -> active(isNat(X))
                mark(0()) -> active(0())
                U11(mark(X1),X2) -> U11(X1,X2)
                U11(X1,mark(X2)) -> U11(X1,X2)
                U11(active(X1),X2) -> U11(X1,X2)
                U11(X1,active(X2)) -> U11(X1,X2)
                U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
                U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
                U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
                U21(active(X1),X2,X3) -> U21(X1,X2,X3)
                U21(X1,active(X2),X3) -> U21(X1,X2,X3)
                U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
                s(mark(X)) -> s(X)
                s(active(X)) -> s(X)
                plus(mark(X1),X2) -> plus(X1,X2)
                plus(X1,mark(X2)) -> plus(X1,X2)
                plus(active(X1),X2) -> plus(X1,X2)
                plus(X1,active(X2)) -> plus(X1,X2)
                and(mark(X1),X2) -> and(X1,X2)
                and(X1,mark(X2)) -> and(X1,X2)
                and(active(X1),X2) -> and(X1,X2)
                and(X1,active(X2)) -> and(X1,X2)
                isNat(mark(X)) -> isNat(X)
                isNat(active(X)) -> isNat(X)
               Arctic Interpretation Processor:
                dimension: 1
                interpretation:
                 [mark#](x0) = x0 + 0,
                 
                 [active#](x0) = x0 + 0,
                 
                 [isNat](x0) = x0 + 0,
                 
                 [0] = 7,
                 
                 [and](x0, x1) = x1,
                 
                 [s](x0) = x0 + 0,
                 
                 [plus](x0, x1) = 4x0 + x1,
                 
                 [U21](x0, x1, x2) = x0 + x1 + 4x2,
                 
                 [mark](x0) = x0,
                 
                 [active](x0) = x0,
                 
                 [U11](x0, x1) = 4x0 + 4x1 + 4,
                 
                 [tt] = 0
                orientation:
                 mark#(s(X)) = X + 0 >= X + 0 = mark#(X)
                 
                 mark#(U11(X1,X2)) = 4X1 + 4X2 + 4 >= X1 + 0 = mark#(X1)
                 
                 mark#(U21(X1,X2,X3)) = X1 + X2 + 4X3 + 0 >= X1 + X2 + 4X3 + 0 = active#(U21(mark(X1),X2,X3))
                 
                 active#(U21(tt(),M,N)) = M + 4N + 0 >= M + 4N + 0 = mark#(s(plus(N,M)))
                 
                 mark#(plus(X1,X2)) = 4X1 + X2 + 0 >= 4X1 + X2 + 0 = active#(plus(mark(X1),mark(X2)))
                 
                 active#(plus(N,s(M))) = M + 4N + 0 >= M + 4N + 0 = mark#(U21(and(isNat(M),isNat(N)),M,N))
                 
                 active(U11(tt(),N)) = 4N + 4 >= N = mark(N)
                 
                 active(U21(tt(),M,N)) = M + 4N + 0 >= M + 4N + 0 = mark(s(plus(N,M)))
                 
                 active(and(tt(),X)) = X >= X = mark(X)
                 
                 active(isNat(0())) = 7 >= 0 = mark(tt())
                 
                 active(isNat(plus(V1,V2))) = 4V1 + V2 + 0 >= V2 + 0 = mark(and(isNat(V1),isNat(V2)))
                 
                 active(isNat(s(V1))) = V1 + 0 >= V1 + 0 = mark(isNat(V1))
                 
                 active(plus(N,0())) = 4N + 7 >= 4N + 4 = mark(U11(isNat(N),N))
                 
                 active(plus(N,s(M))) = M + 4N + 0 >= M + 4N + 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
                 
                 mark(U11(X1,X2)) = 4X1 + 4X2 + 4 >= 4X1 + 4X2 + 4 = active(U11(mark(X1),X2))
                 
                 mark(tt()) = 0 >= 0 = active(tt())
                 
                 mark(U21(X1,X2,X3)) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = active(U21(mark(X1),X2,X3))
                 
                 mark(s(X)) = X + 0 >= X + 0 = active(s(mark(X)))
                 
                 mark(plus(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = active(plus(mark(X1),mark(X2)))
                 
                 mark(and(X1,X2)) = X2 >= X2 = active(and(mark(X1),X2))
                 
                 mark(isNat(X)) = X + 0 >= X + 0 = active(isNat(X))
                 
                 mark(0()) = 7 >= 7 = active(0())
                 
                 U11(mark(X1),X2) = 4X1 + 4X2 + 4 >= 4X1 + 4X2 + 4 = U11(X1,X2)
                 
                 U11(X1,mark(X2)) = 4X1 + 4X2 + 4 >= 4X1 + 4X2 + 4 = U11(X1,X2)
                 
                 U11(active(X1),X2) = 4X1 + 4X2 + 4 >= 4X1 + 4X2 + 4 = U11(X1,X2)
                 
                 U11(X1,active(X2)) = 4X1 + 4X2 + 4 >= 4X1 + 4X2 + 4 = U11(X1,X2)
                 
                 U21(mark(X1),X2,X3) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = U21(X1,X2,X3)
                 
                 U21(X1,mark(X2),X3) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = U21(X1,X2,X3)
                 
                 U21(X1,X2,mark(X3)) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = U21(X1,X2,X3)
                 
                 U21(active(X1),X2,X3) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = U21(X1,X2,X3)
                 
                 U21(X1,active(X2),X3) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = U21(X1,X2,X3)
                 
                 U21(X1,X2,active(X3)) = X1 + X2 + 4X3 >= X1 + X2 + 4X3 = U21(X1,X2,X3)
                 
                 s(mark(X)) = X + 0 >= X + 0 = s(X)
                 
                 s(active(X)) = X + 0 >= X + 0 = s(X)
                 
                 plus(mark(X1),X2) = 4X1 + X2 >= 4X1 + X2 = plus(X1,X2)
                 
                 plus(X1,mark(X2)) = 4X1 + X2 >= 4X1 + X2 = plus(X1,X2)
                 
                 plus(active(X1),X2) = 4X1 + X2 >= 4X1 + X2 = plus(X1,X2)
                 
                 plus(X1,active(X2)) = 4X1 + X2 >= 4X1 + X2 = plus(X1,X2)
                 
                 and(mark(X1),X2) = X2 >= X2 = and(X1,X2)
                 
                 and(X1,mark(X2)) = X2 >= X2 = and(X1,X2)
                 
                 and(active(X1),X2) = X2 >= X2 = and(X1,X2)
                 
                 and(X1,active(X2)) = X2 >= X2 = and(X1,X2)
                 
                 isNat(mark(X)) = X + 0 >= X + 0 = isNat(X)
                 
                 isNat(active(X)) = X + 0 >= X + 0 = isNat(X)
                problem:
                 DPs:
                  mark#(s(X)) -> mark#(X)
                  mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
                  active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
                  mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
                  active#(plus(N,s(M))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
                 TRS:
                  active(U11(tt(),N)) -> mark(N)
                  active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
                  active(and(tt(),X)) -> mark(X)
                  active(isNat(0())) -> mark(tt())
                  active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
                  active(isNat(s(V1))) -> mark(isNat(V1))
                  active(plus(N,0())) -> mark(U11(isNat(N),N))
                  active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
                  mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
                  mark(tt()) -> active(tt())
                  mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
                  mark(s(X)) -> active(s(mark(X)))
                  mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
                  mark(and(X1,X2)) -> active(and(mark(X1),X2))
                  mark(isNat(X)) -> active(isNat(X))
                  mark(0()) -> active(0())
                  U11(mark(X1),X2) -> U11(X1,X2)
                  U11(X1,mark(X2)) -> U11(X1,X2)
                  U11(active(X1),X2) -> U11(X1,X2)
                  U11(X1,active(X2)) -> U11(X1,X2)
                  U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
                  U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
                  U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
                  U21(active(X1),X2,X3) -> U21(X1,X2,X3)
                  U21(X1,active(X2),X3) -> U21(X1,X2,X3)
                  U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
                  s(mark(X)) -> s(X)
                  s(active(X)) -> s(X)
                  plus(mark(X1),X2) -> plus(X1,X2)
                  plus(X1,mark(X2)) -> plus(X1,X2)
                  plus(active(X1),X2) -> plus(X1,X2)
                  plus(X1,active(X2)) -> plus(X1,X2)
                  and(mark(X1),X2) -> and(X1,X2)
                  and(X1,mark(X2)) -> and(X1,X2)
                  and(active(X1),X2) -> and(X1,X2)
                  and(X1,active(X2)) -> and(X1,X2)
                  isNat(mark(X)) -> isNat(X)
                  isNat(active(X)) -> isNat(X)
                KBO Processor:
                 argument filtering:
                  pi(tt) = []
                  pi(U11) = 1
                  pi(active) = 0
                  pi(mark) = 0
                  pi(U21) = [1,2]
                  pi(plus) = [0,1]
                  pi(s) = [0]
                  pi(and) = 1
                  pi(0) = []
                  pi(isNat) = []
                  pi(active#) = 0
                  pi(mark#) = 0
                 weight function:
                  w0 = 1
                  w(isNat) = w(0) = w(s) = w(U21) = w(tt) = 1
                  w(mark#) = w(active#) = w(and) = w(plus) = w(mark) = w(
                  active) = w(U11) = 0
                 precedence:
                  mark# ~ plus > isNat ~ U21 > active# ~ 0 ~ and ~ s ~ mark ~ active ~ U11 ~ tt
                 problem:
                  DPs:
                   mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
                   mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
                  TRS:
                   active(U11(tt(),N)) -> mark(N)
                   active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
                   active(and(tt(),X)) -> mark(X)
                   active(isNat(0())) -> mark(tt())
                   active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
                   active(isNat(s(V1))) -> mark(isNat(V1))
                   active(plus(N,0())) -> mark(U11(isNat(N),N))
                   active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
                   mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
                   mark(tt()) -> active(tt())
                   mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
                   mark(s(X)) -> active(s(mark(X)))
                   mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
                   mark(and(X1,X2)) -> active(and(mark(X1),X2))
                   mark(isNat(X)) -> active(isNat(X))
                   mark(0()) -> active(0())
                   U11(mark(X1),X2) -> U11(X1,X2)
                   U11(X1,mark(X2)) -> U11(X1,X2)
                   U11(active(X1),X2) -> U11(X1,X2)
                   U11(X1,active(X2)) -> U11(X1,X2)
                   U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
                   U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
                   U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
                   U21(active(X1),X2,X3) -> U21(X1,X2,X3)
                   U21(X1,active(X2),X3) -> U21(X1,X2,X3)
                   U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
                   s(mark(X)) -> s(X)
                   s(active(X)) -> s(X)
                   plus(mark(X1),X2) -> plus(X1,X2)
                   plus(X1,mark(X2)) -> plus(X1,X2)
                   plus(active(X1),X2) -> plus(X1,X2)
                   plus(X1,active(X2)) -> plus(X1,X2)
                   and(mark(X1),X2) -> and(X1,X2)
                   and(X1,mark(X2)) -> and(X1,X2)
                   and(active(X1),X2) -> and(X1,X2)
                   and(X1,active(X2)) -> and(X1,X2)
                   isNat(mark(X)) -> isNat(X)
                   isNat(active(X)) -> isNat(X)
                 SCC Processor:
                  #sccs: 0
                  #rules: 0
                  #arcs: 12/4
                  
             
             DPs:
              mark#(isNat(X)) -> active#(isNat(X))
              active#(isNat(s(V1))) -> mark#(isNat(V1))
             TRS:
              active(U11(tt(),N)) -> mark(N)
              active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
              active(and(tt(),X)) -> mark(X)
              active(isNat(0())) -> mark(tt())
              active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
              active(isNat(s(V1))) -> mark(isNat(V1))
              active(plus(N,0())) -> mark(U11(isNat(N),N))
              active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
              mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
              mark(tt()) -> active(tt())
              mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
              mark(s(X)) -> active(s(mark(X)))
              mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
              mark(and(X1,X2)) -> active(and(mark(X1),X2))
              mark(isNat(X)) -> active(isNat(X))
              mark(0()) -> active(0())
              U11(mark(X1),X2) -> U11(X1,X2)
              U11(X1,mark(X2)) -> U11(X1,X2)
              U11(active(X1),X2) -> U11(X1,X2)
              U11(X1,active(X2)) -> U11(X1,X2)
              U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
              U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
              U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
              U21(active(X1),X2,X3) -> U21(X1,X2,X3)
              U21(X1,active(X2),X3) -> U21(X1,X2,X3)
              U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
              s(mark(X)) -> s(X)
              s(active(X)) -> s(X)
              plus(mark(X1),X2) -> plus(X1,X2)
              plus(X1,mark(X2)) -> plus(X1,X2)
              plus(active(X1),X2) -> plus(X1,X2)
              plus(X1,active(X2)) -> plus(X1,X2)
              and(mark(X1),X2) -> and(X1,X2)
              and(X1,mark(X2)) -> and(X1,X2)
              and(active(X1),X2) -> and(X1,X2)
              and(X1,active(X2)) -> and(X1,X2)
              isNat(mark(X)) -> isNat(X)
              isNat(active(X)) -> isNat(X)
             KBO Processor:
              argument filtering:
               pi(tt) = []
               pi(U11) = 1
               pi(active) = 0
               pi(mark) = 0
               pi(U21) = [1,2]
               pi(plus) = [0,1]
               pi(s) = [0]
               pi(and) = 1
               pi(0) = []
               pi(isNat) = 0
               pi(active#) = 0
               pi(mark#) = 0
              weight function:
               w0 = 1
               w(mark#) = w(0) = w(s) = w(U21) = w(active) = w(U11) = w(
               tt) = 1
               w(active#) = w(isNat) = w(and) = w(plus) = w(mark) = 0
              precedence:
               plus > 0 ~ U21 > mark# ~ active# ~ isNat ~ and ~ s ~ mark ~ active ~ U11 ~ tt
              problem:
               DPs:
                mark#(isNat(X)) -> active#(isNat(X))
               TRS:
                active(U11(tt(),N)) -> mark(N)
                active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
                active(and(tt(),X)) -> mark(X)
                active(isNat(0())) -> mark(tt())
                active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
                active(isNat(s(V1))) -> mark(isNat(V1))
                active(plus(N,0())) -> mark(U11(isNat(N),N))
                active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
                mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
                mark(tt()) -> active(tt())
                mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
                mark(s(X)) -> active(s(mark(X)))
                mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
                mark(and(X1,X2)) -> active(and(mark(X1),X2))
                mark(isNat(X)) -> active(isNat(X))
                mark(0()) -> active(0())
                U11(mark(X1),X2) -> U11(X1,X2)
                U11(X1,mark(X2)) -> U11(X1,X2)
                U11(active(X1),X2) -> U11(X1,X2)
                U11(X1,active(X2)) -> U11(X1,X2)
                U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
                U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
                U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
                U21(active(X1),X2,X3) -> U21(X1,X2,X3)
                U21(X1,active(X2),X3) -> U21(X1,X2,X3)
                U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
                s(mark(X)) -> s(X)
                s(active(X)) -> s(X)
                plus(mark(X1),X2) -> plus(X1,X2)
                plus(X1,mark(X2)) -> plus(X1,X2)
                plus(active(X1),X2) -> plus(X1,X2)
                plus(X1,active(X2)) -> plus(X1,X2)
                and(mark(X1),X2) -> and(X1,X2)
                and(X1,mark(X2)) -> and(X1,X2)
                and(active(X1),X2) -> and(X1,X2)
                and(X1,active(X2)) -> and(X1,X2)
                isNat(mark(X)) -> isNat(X)
                isNat(active(X)) -> isNat(X)
              SCC Processor:
               #sccs: 0
               #rules: 0
               #arcs: 2/1
               
    
    DPs:
     plus#(mark(X1),X2) -> plus#(X1,X2)
     plus#(X1,mark(X2)) -> plus#(X1,X2)
     plus#(active(X1),X2) -> plus#(X1,X2)
     plus#(X1,active(X2)) -> plus#(X1,X2)
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    Subterm Criterion Processor:
     simple projection:
      pi(plus#) = 1
     problem:
      DPs:
       plus#(mark(X1),X2) -> plus#(X1,X2)
       plus#(active(X1),X2) -> plus#(X1,X2)
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
     Subterm Criterion Processor:
      simple projection:
       pi(plus#) = 0
      problem:
       DPs:
        
       TRS:
        active(U11(tt(),N)) -> mark(N)
        active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
        active(and(tt(),X)) -> mark(X)
        active(isNat(0())) -> mark(tt())
        active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
        active(isNat(s(V1))) -> mark(isNat(V1))
        active(plus(N,0())) -> mark(U11(isNat(N),N))
        active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
        mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
        mark(tt()) -> active(tt())
        mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
        mark(s(X)) -> active(s(mark(X)))
        mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
        mark(and(X1,X2)) -> active(and(mark(X1),X2))
        mark(isNat(X)) -> active(isNat(X))
        mark(0()) -> active(0())
        U11(mark(X1),X2) -> U11(X1,X2)
        U11(X1,mark(X2)) -> U11(X1,X2)
        U11(active(X1),X2) -> U11(X1,X2)
        U11(X1,active(X2)) -> U11(X1,X2)
        U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
        U21(active(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,active(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        plus(mark(X1),X2) -> plus(X1,X2)
        plus(X1,mark(X2)) -> plus(X1,X2)
        plus(active(X1),X2) -> plus(X1,X2)
        plus(X1,active(X2)) -> plus(X1,X2)
        and(mark(X1),X2) -> and(X1,X2)
        and(X1,mark(X2)) -> and(X1,X2)
        and(active(X1),X2) -> and(X1,X2)
        and(X1,active(X2)) -> and(X1,X2)
        isNat(mark(X)) -> isNat(X)
        isNat(active(X)) -> isNat(X)
      Qed
    
    DPs:
     s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X)
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    Subterm Criterion Processor:
     simple projection:
      pi(s#) = 0
     problem:
      DPs:
       
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
     Qed
    
    DPs:
     isNat#(mark(X)) -> isNat#(X)
     isNat#(active(X)) -> isNat#(X)
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    Subterm Criterion Processor:
     simple projection:
      pi(isNat#) = 0
     problem:
      DPs:
       
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
     Qed
    
    DPs:
     and#(mark(X1),X2) -> and#(X1,X2)
     and#(X1,mark(X2)) -> and#(X1,X2)
     and#(active(X1),X2) -> and#(X1,X2)
     and#(X1,active(X2)) -> and#(X1,X2)
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    Subterm Criterion Processor:
     simple projection:
      pi(and#) = 1
     problem:
      DPs:
       and#(mark(X1),X2) -> and#(X1,X2)
       and#(active(X1),X2) -> and#(X1,X2)
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
     Subterm Criterion Processor:
      simple projection:
       pi(and#) = 0
      problem:
       DPs:
        
       TRS:
        active(U11(tt(),N)) -> mark(N)
        active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
        active(and(tt(),X)) -> mark(X)
        active(isNat(0())) -> mark(tt())
        active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
        active(isNat(s(V1))) -> mark(isNat(V1))
        active(plus(N,0())) -> mark(U11(isNat(N),N))
        active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
        mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
        mark(tt()) -> active(tt())
        mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
        mark(s(X)) -> active(s(mark(X)))
        mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
        mark(and(X1,X2)) -> active(and(mark(X1),X2))
        mark(isNat(X)) -> active(isNat(X))
        mark(0()) -> active(0())
        U11(mark(X1),X2) -> U11(X1,X2)
        U11(X1,mark(X2)) -> U11(X1,X2)
        U11(active(X1),X2) -> U11(X1,X2)
        U11(X1,active(X2)) -> U11(X1,X2)
        U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
        U21(active(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,active(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        plus(mark(X1),X2) -> plus(X1,X2)
        plus(X1,mark(X2)) -> plus(X1,X2)
        plus(active(X1),X2) -> plus(X1,X2)
        plus(X1,active(X2)) -> plus(X1,X2)
        and(mark(X1),X2) -> and(X1,X2)
        and(X1,mark(X2)) -> and(X1,X2)
        and(active(X1),X2) -> and(X1,X2)
        and(X1,active(X2)) -> and(X1,X2)
        isNat(mark(X)) -> isNat(X)
        isNat(active(X)) -> isNat(X)
      Qed
    
    DPs:
     U11#(mark(X1),X2) -> U11#(X1,X2)
     U11#(X1,mark(X2)) -> U11#(X1,X2)
     U11#(active(X1),X2) -> U11#(X1,X2)
     U11#(X1,active(X2)) -> U11#(X1,X2)
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    Subterm Criterion Processor:
     simple projection:
      pi(U11#) = 1
     problem:
      DPs:
       U11#(mark(X1),X2) -> U11#(X1,X2)
       U11#(active(X1),X2) -> U11#(X1,X2)
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
     Subterm Criterion Processor:
      simple projection:
       pi(U11#) = 0
      problem:
       DPs:
        
       TRS:
        active(U11(tt(),N)) -> mark(N)
        active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
        active(and(tt(),X)) -> mark(X)
        active(isNat(0())) -> mark(tt())
        active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
        active(isNat(s(V1))) -> mark(isNat(V1))
        active(plus(N,0())) -> mark(U11(isNat(N),N))
        active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
        mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
        mark(tt()) -> active(tt())
        mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
        mark(s(X)) -> active(s(mark(X)))
        mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
        mark(and(X1,X2)) -> active(and(mark(X1),X2))
        mark(isNat(X)) -> active(isNat(X))
        mark(0()) -> active(0())
        U11(mark(X1),X2) -> U11(X1,X2)
        U11(X1,mark(X2)) -> U11(X1,X2)
        U11(active(X1),X2) -> U11(X1,X2)
        U11(X1,active(X2)) -> U11(X1,X2)
        U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
        U21(active(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,active(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        plus(mark(X1),X2) -> plus(X1,X2)
        plus(X1,mark(X2)) -> plus(X1,X2)
        plus(active(X1),X2) -> plus(X1,X2)
        plus(X1,active(X2)) -> plus(X1,X2)
        and(mark(X1),X2) -> and(X1,X2)
        and(X1,mark(X2)) -> and(X1,X2)
        and(active(X1),X2) -> and(X1,X2)
        and(X1,active(X2)) -> and(X1,X2)
        isNat(mark(X)) -> isNat(X)
        isNat(active(X)) -> isNat(X)
      Qed
    
    DPs:
     U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
     U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
     U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
     U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
     U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
     U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
    TRS:
     active(U11(tt(),N)) -> mark(N)
     active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
     active(and(tt(),X)) -> mark(X)
     active(isNat(0())) -> mark(tt())
     active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
     active(isNat(s(V1))) -> mark(isNat(V1))
     active(plus(N,0())) -> mark(U11(isNat(N),N))
     active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
     mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
     mark(tt()) -> active(tt())
     mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
     mark(s(X)) -> active(s(mark(X)))
     mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
     mark(and(X1,X2)) -> active(and(mark(X1),X2))
     mark(isNat(X)) -> active(isNat(X))
     mark(0()) -> active(0())
     U11(mark(X1),X2) -> U11(X1,X2)
     U11(X1,mark(X2)) -> U11(X1,X2)
     U11(active(X1),X2) -> U11(X1,X2)
     U11(X1,active(X2)) -> U11(X1,X2)
     U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
     U21(active(X1),X2,X3) -> U21(X1,X2,X3)
     U21(X1,active(X2),X3) -> U21(X1,X2,X3)
     U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
     s(mark(X)) -> s(X)
     s(active(X)) -> s(X)
     plus(mark(X1),X2) -> plus(X1,X2)
     plus(X1,mark(X2)) -> plus(X1,X2)
     plus(active(X1),X2) -> plus(X1,X2)
     plus(X1,active(X2)) -> plus(X1,X2)
     and(mark(X1),X2) -> and(X1,X2)
     and(X1,mark(X2)) -> and(X1,X2)
     and(active(X1),X2) -> and(X1,X2)
     and(X1,active(X2)) -> and(X1,X2)
     isNat(mark(X)) -> isNat(X)
     isNat(active(X)) -> isNat(X)
    Subterm Criterion Processor:
     simple projection:
      pi(U21#) = 2
     problem:
      DPs:
       U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
       U21#(X1,mark(X2),X3) -> U21#(X1,X2,X3)
       U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
       U21#(X1,active(X2),X3) -> U21#(X1,X2,X3)
      TRS:
       active(U11(tt(),N)) -> mark(N)
       active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
       active(and(tt(),X)) -> mark(X)
       active(isNat(0())) -> mark(tt())
       active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
       active(isNat(s(V1))) -> mark(isNat(V1))
       active(plus(N,0())) -> mark(U11(isNat(N),N))
       active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
       mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
       mark(tt()) -> active(tt())
       mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
       mark(s(X)) -> active(s(mark(X)))
       mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
       mark(and(X1,X2)) -> active(and(mark(X1),X2))
       mark(isNat(X)) -> active(isNat(X))
       mark(0()) -> active(0())
       U11(mark(X1),X2) -> U11(X1,X2)
       U11(X1,mark(X2)) -> U11(X1,X2)
       U11(active(X1),X2) -> U11(X1,X2)
       U11(X1,active(X2)) -> U11(X1,X2)
       U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
       U21(active(X1),X2,X3) -> U21(X1,X2,X3)
       U21(X1,active(X2),X3) -> U21(X1,X2,X3)
       U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
       s(mark(X)) -> s(X)
       s(active(X)) -> s(X)
       plus(mark(X1),X2) -> plus(X1,X2)
       plus(X1,mark(X2)) -> plus(X1,X2)
       plus(active(X1),X2) -> plus(X1,X2)
       plus(X1,active(X2)) -> plus(X1,X2)
       and(mark(X1),X2) -> and(X1,X2)
       and(X1,mark(X2)) -> and(X1,X2)
       and(active(X1),X2) -> and(X1,X2)
       and(X1,active(X2)) -> and(X1,X2)
       isNat(mark(X)) -> isNat(X)
       isNat(active(X)) -> isNat(X)
     Subterm Criterion Processor:
      simple projection:
       pi(U21#) = 1
      problem:
       DPs:
        U21#(mark(X1),X2,X3) -> U21#(X1,X2,X3)
        U21#(active(X1),X2,X3) -> U21#(X1,X2,X3)
       TRS:
        active(U11(tt(),N)) -> mark(N)
        active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
        active(and(tt(),X)) -> mark(X)
        active(isNat(0())) -> mark(tt())
        active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
        active(isNat(s(V1))) -> mark(isNat(V1))
        active(plus(N,0())) -> mark(U11(isNat(N),N))
        active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
        mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
        mark(tt()) -> active(tt())
        mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
        mark(s(X)) -> active(s(mark(X)))
        mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
        mark(and(X1,X2)) -> active(and(mark(X1),X2))
        mark(isNat(X)) -> active(isNat(X))
        mark(0()) -> active(0())
        U11(mark(X1),X2) -> U11(X1,X2)
        U11(X1,mark(X2)) -> U11(X1,X2)
        U11(active(X1),X2) -> U11(X1,X2)
        U11(X1,active(X2)) -> U11(X1,X2)
        U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
        U21(active(X1),X2,X3) -> U21(X1,X2,X3)
        U21(X1,active(X2),X3) -> U21(X1,X2,X3)
        U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
        s(mark(X)) -> s(X)
        s(active(X)) -> s(X)
        plus(mark(X1),X2) -> plus(X1,X2)
        plus(X1,mark(X2)) -> plus(X1,X2)
        plus(active(X1),X2) -> plus(X1,X2)
        plus(X1,active(X2)) -> plus(X1,X2)
        and(mark(X1),X2) -> and(X1,X2)
        and(X1,mark(X2)) -> and(X1,X2)
        and(active(X1),X2) -> and(X1,X2)
        and(X1,active(X2)) -> and(X1,X2)
        isNat(mark(X)) -> isNat(X)
        isNat(active(X)) -> isNat(X)
      Subterm Criterion Processor:
       simple projection:
        pi(U21#) = 0
       problem:
        DPs:
         
        TRS:
         active(U11(tt(),N)) -> mark(N)
         active(U21(tt(),M,N)) -> mark(s(plus(N,M)))
         active(and(tt(),X)) -> mark(X)
         active(isNat(0())) -> mark(tt())
         active(isNat(plus(V1,V2))) -> mark(and(isNat(V1),isNat(V2)))
         active(isNat(s(V1))) -> mark(isNat(V1))
         active(plus(N,0())) -> mark(U11(isNat(N),N))
         active(plus(N,s(M))) -> mark(U21(and(isNat(M),isNat(N)),M,N))
         mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
         mark(tt()) -> active(tt())
         mark(U21(X1,X2,X3)) -> active(U21(mark(X1),X2,X3))
         mark(s(X)) -> active(s(mark(X)))
         mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
         mark(and(X1,X2)) -> active(and(mark(X1),X2))
         mark(isNat(X)) -> active(isNat(X))
         mark(0()) -> active(0())
         U11(mark(X1),X2) -> U11(X1,X2)
         U11(X1,mark(X2)) -> U11(X1,X2)
         U11(active(X1),X2) -> U11(X1,X2)
         U11(X1,active(X2)) -> U11(X1,X2)
         U21(mark(X1),X2,X3) -> U21(X1,X2,X3)
         U21(X1,mark(X2),X3) -> U21(X1,X2,X3)
         U21(X1,X2,mark(X3)) -> U21(X1,X2,X3)
         U21(active(X1),X2,X3) -> U21(X1,X2,X3)
         U21(X1,active(X2),X3) -> U21(X1,X2,X3)
         U21(X1,X2,active(X3)) -> U21(X1,X2,X3)
         s(mark(X)) -> s(X)
         s(active(X)) -> s(X)
         plus(mark(X1),X2) -> plus(X1,X2)
         plus(X1,mark(X2)) -> plus(X1,X2)
         plus(active(X1),X2) -> plus(X1,X2)
         plus(X1,active(X2)) -> plus(X1,X2)
         and(mark(X1),X2) -> and(X1,X2)
         and(X1,mark(X2)) -> and(X1,X2)
         and(active(X1),X2) -> and(X1,X2)
         and(X1,active(X2)) -> and(X1,X2)
         isNat(mark(X)) -> isNat(X)
         isNat(active(X)) -> isNat(X)
       Qed