MAYBE

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#(M) ->
    isNat#(active(X)) -> isNat#(X)
    active#(plus(N,s(M))) -> isNat#(M) ->
    isNat#(mark(X)) -> isNat#(X)
    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))) -> 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)
   EDG 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#(mark(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#(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#(active(X1),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#(mark(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#(mark(X1),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#(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#(active(X1),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#(active(X1),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#(mark(X1),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#(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#(active(X1),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#(X1,mark(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#(mark(X1),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#(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#(active(X1),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#(X1,active(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#(mark(X1),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,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#(active(X1),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,X2,mark(X3)) -> U21#(X1,X2,X3) ->
     U21#(X1,X2,active(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,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#(X1,X2,mark(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,active(X2),X3) -> U21#(X1,X2,X3)
     U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3) ->
     U21#(X1,X2,active(X3)) -> U21#(X1,X2,X3)
     U11#(mark(X1),X2) -> U11#(X1,X2) ->
     U11#(mark(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#(active(X1),X2) -> U11#(X1,X2)
     U11#(mark(X1),X2) -> U11#(X1,X2) ->
     U11#(X1,active(X2)) -> U11#(X1,X2)
     U11#(active(X1),X2) -> U11#(X1,X2) ->
     U11#(mark(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#(active(X1),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#(mark(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#(active(X1),X2) -> U11#(X1,X2)
     U11#(X1,mark(X2)) -> U11#(X1,X2) ->
     U11#(X1,active(X2)) -> U11#(X1,X2)
     U11#(X1,active(X2)) -> U11#(X1,X2) ->
     U11#(mark(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#(active(X1),X2) -> U11#(X1,X2)
     U11#(X1,active(X2)) -> U11#(X1,X2) ->
     U11#(X1,active(X2)) -> U11#(X1,X2)
     and#(mark(X1),X2) -> and#(X1,X2) ->
     and#(mark(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#(active(X1),X2) -> and#(X1,X2)
     and#(mark(X1),X2) -> and#(X1,X2) ->
     and#(X1,active(X2)) -> and#(X1,X2)
     and#(active(X1),X2) -> and#(X1,X2) ->
     and#(mark(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#(active(X1),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#(mark(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#(active(X1),X2) -> and#(X1,X2)
     and#(X1,mark(X2)) -> and#(X1,X2) ->
     and#(X1,active(X2)) -> and#(X1,X2)
     and#(X1,active(X2)) -> and#(X1,X2) ->
     and#(mark(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#(active(X1),X2) -> and#(X1,X2)
     and#(X1,active(X2)) -> and#(X1,X2) ->
     and#(X1,active(X2)) -> and#(X1,X2)
     isNat#(mark(X)) -> isNat#(X) -> isNat#(mark(X)) -> isNat#(X)
     isNat#(mark(X)) -> isNat#(X) -> isNat#(active(X)) -> isNat#(X)
     isNat#(active(X)) -> isNat#(X) -> isNat#(mark(X)) -> isNat#(X)
     isNat#(active(X)) -> isNat#(X) -> isNat#(active(X)) -> isNat#(X)
     s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
     s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X)
     s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
     s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X)
     plus#(mark(X1),X2) -> plus#(X1,X2) ->
     plus#(mark(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#(active(X1),X2) -> plus#(X1,X2)
     plus#(mark(X1),X2) -> plus#(X1,X2) ->
     plus#(X1,active(X2)) -> plus#(X1,X2)
     plus#(active(X1),X2) -> plus#(X1,X2) ->
     plus#(mark(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#(active(X1),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#(mark(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#(active(X1),X2) -> plus#(X1,X2)
     plus#(X1,mark(X2)) -> plus#(X1,X2) ->
     plus#(X1,active(X2)) -> plus#(X1,X2)
     plus#(X1,active(X2)) -> plus#(X1,X2) ->
     plus#(mark(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#(active(X1),X2) -> plus#(X1,X2)
     plus#(X1,active(X2)) -> plus#(X1,X2) ->
     plus#(X1,active(X2)) -> plus#(X1,X2)
     mark#(isNat(X)) -> active#(isNat(X)) ->
     active#(isNat(0())) -> mark#(tt())
     mark#(isNat(X)) -> active#(isNat(X)) ->
     active#(isNat(plus(V1,V2))) -> 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))) -> and#(isNat(V1),isNat(V2))
     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))) -> isNat#(V1)
     mark#(isNat(X)) -> active#(isNat(X)) ->
     active#(isNat(s(V1))) -> mark#(isNat(V1))
     mark#(and(X1,X2)) -> and#(mark(X1),X2) ->
     and#(mark(X1),X2) -> and#(X1,X2)
     mark#(and(X1,X2)) -> and#(mark(X1),X2) ->
     and#(active(X1),X2) -> and#(X1,X2)
     mark#(and(X1,X2)) -> mark#(X1) -> mark#(U11(X1,X2)) -> mark#(X1)
     mark#(and(X1,X2)) -> mark#(X1) ->
     mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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)) -> 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)) -> 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))) -> 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))) -> 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)) -> active#(and(mark(X1),X2)) ->
     active#(isNat(s(V1))) -> isNat#(V1)
     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())) -> isNat#(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())) -> mark#(U11(isNat(N),N))
     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,s(M))) -> isNat#(M)
     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))) -> 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#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X)
     mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X)
     mark#(s(X)) -> mark#(X) -> mark#(U11(X1,X2)) -> mark#(X1)
     mark#(s(X)) -> mark#(X) -> mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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)) -> 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)) -> 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))) -> 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))) -> 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)) -> active#(s(mark(X))) ->
     active#(isNat(s(V1))) -> isNat#(V1)
     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())) -> isNat#(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())) -> mark#(U11(isNat(N),N))
     mark#(s(X)) -> active#(s(mark(X))) ->
     active#(plus(N,s(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))) -> and#(isNat(M),isNat(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))) -> mark#(U21(and(isNat(M),isNat(N)),M,N))
     mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2)) ->
     plus#(mark(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#(active(X1),X2) -> plus#(X1,X2)
     mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2)) ->
     plus#(X1,active(X2)) -> plus#(X1,X2)
     mark#(plus(X1,X2)) -> mark#(X2) ->
     mark#(U11(X1,X2)) -> mark#(X1)
     mark#(plus(X1,X2)) -> mark#(X2) ->
     mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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)) -> 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)) -> 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))) -> 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))) -> 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)) -> active#(plus(mark(X1),mark(X2))) ->
     active#(isNat(s(V1))) -> isNat#(V1)
     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())) -> isNat#(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())) -> mark#(U11(isNat(N),N))
     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,s(M))) -> isNat#(M)
     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))) -> 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#(U21(X1,X2,X3)) -> U21#(mark(X1),X2,X3) ->
     U21#(mark(X1),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)) -> mark#(X1) ->
     mark#(U11(X1,X2)) -> mark#(X1)
     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)) -> 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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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)) -> 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)) -> 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))) -> 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))) -> 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)) -> 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(s(V1))) -> mark#(isNat(V1))
     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#(plus(N,0())) -> 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)) -> 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,s(M))) -> isNat#(M)
     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))) -> 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#(U11(X1,X2)) -> U11#(mark(X1),X2) ->
     U11#(mark(X1),X2) -> U11#(X1,X2)
     mark#(U11(X1,X2)) -> U11#(mark(X1),X2) ->
     U11#(active(X1),X2) -> U11#(X1,X2)
     mark#(U11(X1,X2)) -> mark#(X1) -> mark#(U11(X1,X2)) -> mark#(X1)
     mark#(U11(X1,X2)) -> mark#(X1) ->
     mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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)) -> 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)) -> 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))) -> 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))) -> 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)) -> active#(U11(mark(X1),X2)) ->
     active#(isNat(s(V1))) -> isNat#(V1)
     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())) -> isNat#(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())) -> mark#(U11(isNat(N),N))
     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,s(M))) -> isNat#(M)
     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))) -> 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))
     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)) -> U11#(mark(X1),X2)
     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)) -> 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))) -> mark#(isNat(V1)) ->
     mark#(s(X)) -> 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)) -> 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)) -> 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))) -> mark#(isNat(V1)) ->
     mark#(and(X1,X2)) -> mark#(X1)
     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)) -> active#(and(mark(X1),X2))
     active#(isNat(s(V1))) -> mark#(isNat(V1)) ->
     mark#(isNat(X)) -> active#(isNat(X))
     active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2)) ->
     and#(mark(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#(active(X1),X2) -> and#(X1,X2)
     active#(isNat(plus(V1,V2))) -> and#(isNat(V1),isNat(V2)) ->
     and#(X1,active(X2)) -> and#(X1,X2)
     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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> 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)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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())) -> U11#(isNat(N),N) ->
     U11#(mark(X1),X2) -> U11#(X1,X2)
     active#(plus(N,0())) -> U11#(isNat(N),N) ->
     U11#(active(X1),X2) -> U11#(X1,X2)
     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)) -> 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())) -> 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)) -> 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())) -> mark#(U11(isNat(N),N)) ->
     mark#(s(X)) -> 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)) -> 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)) -> 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())) -> mark#(U11(isNat(N),N)) ->
     mark#(and(X1,X2)) -> mark#(X1)
     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)) -> 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))) -> U21#(and(isNat(M),isNat(N)),M,N) ->
     U21#(mark(X1),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))) -> and#(isNat(M),isNat(N)) ->
     and#(mark(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#(active(X1),X2) -> and#(X1,X2)
     active#(plus(N,s(M))) -> and#(isNat(M),isNat(N)) ->
     and#(X1,active(X2)) -> and#(X1,X2)
     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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> 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)) -> 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))) -> mark#(U21(and(isNat(M),isNat(N)),M,N)) ->
     mark#(isNat(X)) -> active#(isNat(X))
     active#(U21(tt(),M,N)) -> s#(plus(N,M)) ->
     s#(mark(X)) -> s#(X)
     active#(U21(tt(),M,N)) -> s#(plus(N,M)) ->
     s#(active(X)) -> s#(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)) -> 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)) -> 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)) -> 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)) -> mark#(s(plus(N,M))) ->
     mark#(s(X)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> 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)) -> U11#(mark(X1),X2)
     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)) -> U21#(mark(X1),X2,X3)
     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)) -> s#(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)) -> plus#(mark(X1),mark(X2))
     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)) -> and#(mark(X1),X2)
     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())
    SCC Processor:
     #sccs: 7
     #rules: 41
     #arcs: 463/3721
     DPs:
      mark#(isNat(X)) -> active#(isNat(X))
      active#(isNat(s(V1))) -> mark#(isNat(V1))
      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)) -> mark#(X1)
      mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
      active#(plus(N,0())) -> mark#(U11(isNat(N),N))
      mark#(plus(X1,X2)) -> mark#(X1)
      mark#(plus(X1,X2)) -> mark#(X2)
      mark#(s(X)) -> active#(s(mark(X)))
      active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
      mark#(s(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)
      mark#(U11(X1,X2)) -> active#(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)
     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)
     Matrix Interpretation Processor:
      dimension: 1
      interpretation:
       [mark#](x0) = 1,
       
       [active#](x0) = x0,
       
       [isNat](x0) = 1,
       
       [0] = 0,
       
       [and](x0, x1) = 1,
       
       [s](x0) = 0,
       
       [plus](x0, x1) = 1,
       
       [U21](x0, x1, x2) = 1,
       
       [mark](x0) = 1,
       
       [active](x0) = 1,
       
       [U11](x0, x1) = 1,
       
       [tt] = 0
      orientation:
       mark#(isNat(X)) = 1 >= 1 = active#(isNat(X))
       
       active#(isNat(s(V1))) = 1 >= 1 = mark#(isNat(V1))
       
       mark#(and(X1,X2)) = 1 >= 1 = active#(and(mark(X1),X2))
       
       active#(plus(N,s(M))) = 1 >= 1 = mark#(U21(and(isNat(M),isNat(N)),M,N))
       
       mark#(and(X1,X2)) = 1 >= 1 = mark#(X1)
       
       mark#(plus(X1,X2)) = 1 >= 1 = active#(plus(mark(X1),mark(X2)))
       
       active#(plus(N,0())) = 1 >= 1 = mark#(U11(isNat(N),N))
       
       mark#(plus(X1,X2)) = 1 >= 1 = mark#(X1)
       
       mark#(plus(X1,X2)) = 1 >= 1 = mark#(X2)
       
       mark#(s(X)) = 1 >= 0 = active#(s(mark(X)))
       
       active#(isNat(plus(V1,V2))) = 1 >= 1 = mark#(and(isNat(V1),isNat(V2)))
       
       mark#(s(X)) = 1 >= 1 = mark#(X)
       
       mark#(U21(X1,X2,X3)) = 1 >= 1 = active#(U21(mark(X1),X2,X3))
       
       active#(and(tt(),X)) = 1 >= 1 = mark#(X)
       
       mark#(U21(X1,X2,X3)) = 1 >= 1 = mark#(X1)
       
       mark#(U11(X1,X2)) = 1 >= 1 = active#(U11(mark(X1),X2))
       
       active#(U21(tt(),M,N)) = 1 >= 1 = mark#(s(plus(N,M)))
       
       mark#(U11(X1,X2)) = 1 >= 1 = mark#(X1)
       
       active#(U11(tt(),N)) = 1 >= 1 = mark#(N)
       
       active(U11(tt(),N)) = 1 >= 1 = mark(N)
       
       active(U21(tt(),M,N)) = 1 >= 1 = mark(s(plus(N,M)))
       
       active(and(tt(),X)) = 1 >= 1 = mark(X)
       
       active(isNat(0())) = 1 >= 1 = mark(tt())
       
       active(isNat(plus(V1,V2))) = 1 >= 1 = mark(and(isNat(V1),isNat(V2)))
       
       active(isNat(s(V1))) = 1 >= 1 = mark(isNat(V1))
       
       active(plus(N,0())) = 1 >= 1 = mark(U11(isNat(N),N))
       
       active(plus(N,s(M))) = 1 >= 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
       
       mark(U11(X1,X2)) = 1 >= 1 = active(U11(mark(X1),X2))
       
       mark(tt()) = 1 >= 1 = active(tt())
       
       mark(U21(X1,X2,X3)) = 1 >= 1 = active(U21(mark(X1),X2,X3))
       
       mark(s(X)) = 1 >= 1 = active(s(mark(X)))
       
       mark(plus(X1,X2)) = 1 >= 1 = active(plus(mark(X1),mark(X2)))
       
       mark(and(X1,X2)) = 1 >= 1 = active(and(mark(X1),X2))
       
       mark(isNat(X)) = 1 >= 1 = active(isNat(X))
       
       mark(0()) = 1 >= 1 = active(0())
       
       U11(mark(X1),X2) = 1 >= 1 = U11(X1,X2)
       
       U11(X1,mark(X2)) = 1 >= 1 = U11(X1,X2)
       
       U11(active(X1),X2) = 1 >= 1 = U11(X1,X2)
       
       U11(X1,active(X2)) = 1 >= 1 = U11(X1,X2)
       
       U21(mark(X1),X2,X3) = 1 >= 1 = U21(X1,X2,X3)
       
       U21(X1,mark(X2),X3) = 1 >= 1 = U21(X1,X2,X3)
       
       U21(X1,X2,mark(X3)) = 1 >= 1 = U21(X1,X2,X3)
       
       U21(active(X1),X2,X3) = 1 >= 1 = U21(X1,X2,X3)
       
       U21(X1,active(X2),X3) = 1 >= 1 = U21(X1,X2,X3)
       
       U21(X1,X2,active(X3)) = 1 >= 1 = U21(X1,X2,X3)
       
       s(mark(X)) = 0 >= 0 = s(X)
       
       s(active(X)) = 0 >= 0 = s(X)
       
       plus(mark(X1),X2) = 1 >= 1 = plus(X1,X2)
       
       plus(X1,mark(X2)) = 1 >= 1 = plus(X1,X2)
       
       plus(active(X1),X2) = 1 >= 1 = plus(X1,X2)
       
       plus(X1,active(X2)) = 1 >= 1 = plus(X1,X2)
       
       and(mark(X1),X2) = 1 >= 1 = and(X1,X2)
       
       and(X1,mark(X2)) = 1 >= 1 = and(X1,X2)
       
       and(active(X1),X2) = 1 >= 1 = and(X1,X2)
       
       and(X1,active(X2)) = 1 >= 1 = and(X1,X2)
       
       isNat(mark(X)) = 1 >= 1 = isNat(X)
       
       isNat(active(X)) = 1 >= 1 = isNat(X)
      problem:
       DPs:
        mark#(isNat(X)) -> active#(isNat(X))
        active#(isNat(s(V1))) -> mark#(isNat(V1))
        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)) -> mark#(X1)
        mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
        active#(plus(N,0())) -> mark#(U11(isNat(N),N))
        mark#(plus(X1,X2)) -> mark#(X1)
        mark#(plus(X1,X2)) -> mark#(X2)
        active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
        mark#(s(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)
        mark#(U11(X1,X2)) -> active#(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)
       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)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [mark#](x0) = x0,
        
        [active#](x0) = x0,
        
        [isNat](x0) = 0,
        
        [0] = 1,
        
        [and](x0, x1) = x0 + x1,
        
        [s](x0) = x0,
        
        [plus](x0, x1) = x0 + x1,
        
        [U21](x0, x1, x2) = x0 + x1 + x2,
        
        [mark](x0) = x0,
        
        [active](x0) = x0,
        
        [U11](x0, x1) = x0 + x1,
        
        [tt] = 0
       orientation:
        mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
        
        active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
        
        mark#(and(X1,X2)) = X1 + X2 >= X1 + X2 = active#(and(mark(X1),X2))
        
        active#(plus(N,s(M))) = M + N >= M + N = mark#(U21(and(isNat(M),isNat(N)),M,N))
        
        mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
        
        mark#(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active#(plus(mark(X1),mark(X2)))
        
        active#(plus(N,0())) = N + 1 >= N = mark#(U11(isNat(N),N))
        
        mark#(plus(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
        
        mark#(plus(X1,X2)) = X1 + X2 >= X2 = mark#(X2)
        
        active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
        
        mark#(s(X)) = X >= X = mark#(X)
        
        mark#(U21(X1,X2,X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = active#(U21(mark(X1),X2,X3))
        
        active#(and(tt(),X)) = X >= X = mark#(X)
        
        mark#(U21(X1,X2,X3)) = X1 + X2 + X3 >= X1 = mark#(X1)
        
        mark#(U11(X1,X2)) = X1 + X2 >= X1 + X2 = active#(U11(mark(X1),X2))
        
        active#(U21(tt(),M,N)) = M + N >= M + N = mark#(s(plus(N,M)))
        
        mark#(U11(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
        
        active#(U11(tt(),N)) = N >= N = mark#(N)
        
        active(U11(tt(),N)) = N >= N = mark(N)
        
        active(U21(tt(),M,N)) = M + N >= M + N = mark(s(plus(N,M)))
        
        active(and(tt(),X)) = X >= X = 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())) = N + 1 >= N = mark(U11(isNat(N),N))
        
        active(plus(N,s(M))) = M + N >= M + N = mark(U21(and(isNat(M),isNat(N)),M,N))
        
        mark(U11(X1,X2)) = X1 + X2 >= X1 + X2 = active(U11(mark(X1),X2))
        
        mark(tt()) = 0 >= 0 = active(tt())
        
        mark(U21(X1,X2,X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = active(U21(mark(X1),X2,X3))
        
        mark(s(X)) = X >= X = active(s(mark(X)))
        
        mark(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active(plus(mark(X1),mark(X2)))
        
        mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
        
        mark(isNat(X)) = 0 >= 0 = active(isNat(X))
        
        mark(0()) = 1 >= 1 = active(0())
        
        U11(mark(X1),X2) = X1 + X2 >= X1 + X2 = U11(X1,X2)
        
        U11(X1,mark(X2)) = X1 + X2 >= 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) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
        
        U21(X1,mark(X2),X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
        
        U21(X1,X2,mark(X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
        
        U21(active(X1),X2,X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
        
        U21(X1,active(X2),X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
        
        U21(X1,X2,active(X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
        
        s(mark(X)) = X >= X = s(X)
        
        s(active(X)) = X >= X = s(X)
        
        plus(mark(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
        
        plus(X1,mark(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
        
        plus(active(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
        
        plus(X1,active(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
        
        and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
        
        and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
        
        and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
        
        and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
         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)) -> mark#(X1)
         mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
         mark#(plus(X1,X2)) -> mark#(X1)
         mark#(plus(X1,X2)) -> mark#(X2)
         active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
         mark#(s(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)
         mark#(U11(X1,X2)) -> active#(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)
        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)
       Matrix Interpretation Processor:
        dimension: 1
        interpretation:
         [mark#](x0) = x0,
         
         [active#](x0) = x0,
         
         [isNat](x0) = 0,
         
         [0] = 1,
         
         [and](x0, x1) = x0 + x1,
         
         [s](x0) = x0,
         
         [plus](x0, x1) = x0 + x1,
         
         [U21](x0, x1, x2) = x0 + x1 + x2,
         
         [mark](x0) = x0,
         
         [active](x0) = x0,
         
         [U11](x0, x1) = x0 + x1 + 1,
         
         [tt] = 0
        orientation:
         mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
         
         active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
         
         mark#(and(X1,X2)) = X1 + X2 >= X1 + X2 = active#(and(mark(X1),X2))
         
         active#(plus(N,s(M))) = M + N >= M + N = mark#(U21(and(isNat(M),isNat(N)),M,N))
         
         mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
         
         mark#(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active#(plus(mark(X1),mark(X2)))
         
         mark#(plus(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
         
         mark#(plus(X1,X2)) = X1 + X2 >= X2 = mark#(X2)
         
         active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
         
         mark#(s(X)) = X >= X = mark#(X)
         
         mark#(U21(X1,X2,X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = active#(U21(mark(X1),X2,X3))
         
         active#(and(tt(),X)) = X >= X = mark#(X)
         
         mark#(U21(X1,X2,X3)) = X1 + X2 + X3 >= X1 = mark#(X1)
         
         mark#(U11(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active#(U11(mark(X1),X2))
         
         active#(U21(tt(),M,N)) = M + N >= M + N = mark#(s(plus(N,M)))
         
         mark#(U11(X1,X2)) = X1 + X2 + 1 >= X1 = mark#(X1)
         
         active#(U11(tt(),N)) = N + 1 >= N = mark#(N)
         
         active(U11(tt(),N)) = N + 1 >= N = mark(N)
         
         active(U21(tt(),M,N)) = M + N >= M + N = mark(s(plus(N,M)))
         
         active(and(tt(),X)) = X >= X = 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())) = N + 1 >= N + 1 = mark(U11(isNat(N),N))
         
         active(plus(N,s(M))) = M + N >= M + N = mark(U21(and(isNat(M),isNat(N)),M,N))
         
         mark(U11(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(U11(mark(X1),X2))
         
         mark(tt()) = 0 >= 0 = active(tt())
         
         mark(U21(X1,X2,X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = active(U21(mark(X1),X2,X3))
         
         mark(s(X)) = X >= X = active(s(mark(X)))
         
         mark(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active(plus(mark(X1),mark(X2)))
         
         mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
         
         mark(isNat(X)) = 0 >= 0 = active(isNat(X))
         
         mark(0()) = 1 >= 1 = active(0())
         
         U11(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = U11(X1,X2)
         
         U11(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = U11(X1,X2)
         
         U11(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = U11(X1,X2)
         
         U11(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = U11(X1,X2)
         
         U21(mark(X1),X2,X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
         
         U21(X1,mark(X2),X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
         
         U21(X1,X2,mark(X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
         
         U21(active(X1),X2,X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
         
         U21(X1,active(X2),X3) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
         
         U21(X1,X2,active(X3)) = X1 + X2 + X3 >= X1 + X2 + X3 = U21(X1,X2,X3)
         
         s(mark(X)) = X >= X = s(X)
         
         s(active(X)) = X >= X = s(X)
         
         plus(mark(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
         
         plus(X1,mark(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
         
         plus(active(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
         
         plus(X1,active(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
         
         and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
         
         and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
         
         and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
         
         and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
          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)) -> mark#(X1)
          mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
          mark#(plus(X1,X2)) -> mark#(X1)
          mark#(plus(X1,X2)) -> mark#(X2)
          active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
          mark#(s(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)
          mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
          active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
         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)
        Matrix Interpretation Processor:
         dimension: 1
         interpretation:
          [mark#](x0) = 1,
          
          [active#](x0) = x0,
          
          [isNat](x0) = 1,
          
          [0] = 0,
          
          [and](x0, x1) = 1,
          
          [s](x0) = 0,
          
          [plus](x0, x1) = 1,
          
          [U21](x0, x1, x2) = 1,
          
          [mark](x0) = 0,
          
          [active](x0) = 0,
          
          [U11](x0, x1) = 0,
          
          [tt] = 0
         orientation:
          mark#(isNat(X)) = 1 >= 1 = active#(isNat(X))
          
          active#(isNat(s(V1))) = 1 >= 1 = mark#(isNat(V1))
          
          mark#(and(X1,X2)) = 1 >= 1 = active#(and(mark(X1),X2))
          
          active#(plus(N,s(M))) = 1 >= 1 = mark#(U21(and(isNat(M),isNat(N)),M,N))
          
          mark#(and(X1,X2)) = 1 >= 1 = mark#(X1)
          
          mark#(plus(X1,X2)) = 1 >= 1 = active#(plus(mark(X1),mark(X2)))
          
          mark#(plus(X1,X2)) = 1 >= 1 = mark#(X1)
          
          mark#(plus(X1,X2)) = 1 >= 1 = mark#(X2)
          
          active#(isNat(plus(V1,V2))) = 1 >= 1 = mark#(and(isNat(V1),isNat(V2)))
          
          mark#(s(X)) = 1 >= 1 = mark#(X)
          
          mark#(U21(X1,X2,X3)) = 1 >= 1 = active#(U21(mark(X1),X2,X3))
          
          active#(and(tt(),X)) = 1 >= 1 = mark#(X)
          
          mark#(U21(X1,X2,X3)) = 1 >= 1 = mark#(X1)
          
          mark#(U11(X1,X2)) = 1 >= 0 = active#(U11(mark(X1),X2))
          
          active#(U21(tt(),M,N)) = 1 >= 1 = mark#(s(plus(N,M)))
          
          active(U11(tt(),N)) = 0 >= 0 = mark(N)
          
          active(U21(tt(),M,N)) = 0 >= 0 = mark(s(plus(N,M)))
          
          active(and(tt(),X)) = 0 >= 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())) = 0 >= 0 = mark(U11(isNat(N),N))
          
          active(plus(N,s(M))) = 0 >= 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
          
          mark(U11(X1,X2)) = 0 >= 0 = active(U11(mark(X1),X2))
          
          mark(tt()) = 0 >= 0 = active(tt())
          
          mark(U21(X1,X2,X3)) = 0 >= 0 = active(U21(mark(X1),X2,X3))
          
          mark(s(X)) = 0 >= 0 = active(s(mark(X)))
          
          mark(plus(X1,X2)) = 0 >= 0 = active(plus(mark(X1),mark(X2)))
          
          mark(and(X1,X2)) = 0 >= 0 = active(and(mark(X1),X2))
          
          mark(isNat(X)) = 0 >= 0 = active(isNat(X))
          
          mark(0()) = 0 >= 0 = active(0())
          
          U11(mark(X1),X2) = 0 >= 0 = U11(X1,X2)
          
          U11(X1,mark(X2)) = 0 >= 0 = U11(X1,X2)
          
          U11(active(X1),X2) = 0 >= 0 = U11(X1,X2)
          
          U11(X1,active(X2)) = 0 >= 0 = U11(X1,X2)
          
          U21(mark(X1),X2,X3) = 1 >= 1 = U21(X1,X2,X3)
          
          U21(X1,mark(X2),X3) = 1 >= 1 = U21(X1,X2,X3)
          
          U21(X1,X2,mark(X3)) = 1 >= 1 = U21(X1,X2,X3)
          
          U21(active(X1),X2,X3) = 1 >= 1 = U21(X1,X2,X3)
          
          U21(X1,active(X2),X3) = 1 >= 1 = U21(X1,X2,X3)
          
          U21(X1,X2,active(X3)) = 1 >= 1 = U21(X1,X2,X3)
          
          s(mark(X)) = 0 >= 0 = s(X)
          
          s(active(X)) = 0 >= 0 = s(X)
          
          plus(mark(X1),X2) = 1 >= 1 = plus(X1,X2)
          
          plus(X1,mark(X2)) = 1 >= 1 = plus(X1,X2)
          
          plus(active(X1),X2) = 1 >= 1 = plus(X1,X2)
          
          plus(X1,active(X2)) = 1 >= 1 = plus(X1,X2)
          
          and(mark(X1),X2) = 1 >= 1 = and(X1,X2)
          
          and(X1,mark(X2)) = 1 >= 1 = and(X1,X2)
          
          and(active(X1),X2) = 1 >= 1 = and(X1,X2)
          
          and(X1,active(X2)) = 1 >= 1 = and(X1,X2)
          
          isNat(mark(X)) = 1 >= 1 = isNat(X)
          
          isNat(active(X)) = 1 >= 1 = isNat(X)
         problem:
          DPs:
           mark#(isNat(X)) -> active#(isNat(X))
           active#(isNat(s(V1))) -> mark#(isNat(V1))
           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)) -> mark#(X1)
           mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
           mark#(plus(X1,X2)) -> mark#(X1)
           mark#(plus(X1,X2)) -> mark#(X2)
           active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
           mark#(s(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#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
          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)
         Matrix Interpretation Processor:
          dimension: 1
          interpretation:
           [mark#](x0) = x0,
           
           [active#](x0) = x0,
           
           [isNat](x0) = 0,
           
           [0] = 0,
           
           [and](x0, x1) = x0 + x1,
           
           [s](x0) = x0 + 1,
           
           [plus](x0, x1) = x0 + x1,
           
           [U21](x0, x1, x2) = x0 + x1 + x2 + 1,
           
           [mark](x0) = x0,
           
           [active](x0) = x0,
           
           [U11](x0, x1) = x1,
           
           [tt] = 0
          orientation:
           mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
           
           active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
           
           mark#(and(X1,X2)) = X1 + X2 >= X1 + X2 = active#(and(mark(X1),X2))
           
           active#(plus(N,s(M))) = M + N + 1 >= M + N + 1 = mark#(U21(and(isNat(M),isNat(N)),M,N))
           
           mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
           
           mark#(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active#(plus(mark(X1),mark(X2)))
           
           mark#(plus(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
           
           mark#(plus(X1,X2)) = X1 + X2 >= X2 = mark#(X2)
           
           active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
           
           mark#(s(X)) = X + 1 >= X = mark#(X)
           
           mark#(U21(X1,X2,X3)) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = active#(U21(mark(X1),X2,X3))
           
           active#(and(tt(),X)) = X >= X = mark#(X)
           
           mark#(U21(X1,X2,X3)) = X1 + X2 + X3 + 1 >= X1 = mark#(X1)
           
           active#(U21(tt(),M,N)) = M + N + 1 >= M + N + 1 = mark#(s(plus(N,M)))
           
           active(U11(tt(),N)) = N >= N = mark(N)
           
           active(U21(tt(),M,N)) = M + N + 1 >= M + N + 1 = mark(s(plus(N,M)))
           
           active(and(tt(),X)) = X >= X = 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())) = N >= N = mark(U11(isNat(N),N))
           
           active(plus(N,s(M))) = M + N + 1 >= M + N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
           
           mark(U11(X1,X2)) = X2 >= X2 = active(U11(mark(X1),X2))
           
           mark(tt()) = 0 >= 0 = active(tt())
           
           mark(U21(X1,X2,X3)) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = active(U21(mark(X1),X2,X3))
           
           mark(s(X)) = X + 1 >= X + 1 = active(s(mark(X)))
           
           mark(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active(plus(mark(X1),mark(X2)))
           
           mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
           
           mark(isNat(X)) = 0 >= 0 = active(isNat(X))
           
           mark(0()) = 0 >= 0 = active(0())
           
           U11(mark(X1),X2) = X2 >= X2 = U11(X1,X2)
           
           U11(X1,mark(X2)) = X2 >= X2 = U11(X1,X2)
           
           U11(active(X1),X2) = X2 >= X2 = U11(X1,X2)
           
           U11(X1,active(X2)) = X2 >= X2 = U11(X1,X2)
           
           U21(mark(X1),X2,X3) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = U21(X1,X2,X3)
           
           U21(X1,mark(X2),X3) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = U21(X1,X2,X3)
           
           U21(X1,X2,mark(X3)) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = U21(X1,X2,X3)
           
           U21(active(X1),X2,X3) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = U21(X1,X2,X3)
           
           U21(X1,active(X2),X3) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = U21(X1,X2,X3)
           
           U21(X1,X2,active(X3)) = X1 + X2 + X3 + 1 >= X1 + X2 + X3 + 1 = U21(X1,X2,X3)
           
           s(mark(X)) = X + 1 >= X + 1 = s(X)
           
           s(active(X)) = X + 1 >= X + 1 = s(X)
           
           plus(mark(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
           
           plus(X1,mark(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
           
           plus(active(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
           
           plus(X1,active(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
           
           and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
           
           and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
           
           and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
           
           and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
            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)) -> mark#(X1)
            mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
            mark#(plus(X1,X2)) -> mark#(X1)
            mark#(plus(X1,X2)) -> mark#(X2)
            active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
            mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
            active#(and(tt(),X)) -> mark#(X)
            active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
           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)
          Matrix Interpretation Processor:
           dimension: 1
           interpretation:
            [mark#](x0) = x0,
            
            [active#](x0) = x0,
            
            [isNat](x0) = 0,
            
            [0] = 0,
            
            [and](x0, x1) = x0 + x1,
            
            [s](x0) = 0,
            
            [plus](x0, x1) = x0 + x1 + 1,
            
            [U21](x0, x1, x2) = 0,
            
            [mark](x0) = x0,
            
            [active](x0) = x0,
            
            [U11](x0, x1) = x1,
            
            [tt] = 0
           orientation:
            mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
            
            active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
            
            mark#(and(X1,X2)) = X1 + X2 >= X1 + X2 = active#(and(mark(X1),X2))
            
            active#(plus(N,s(M))) = N + 1 >= 0 = mark#(U21(and(isNat(M),isNat(N)),M,N))
            
            mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
            
            mark#(plus(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active#(plus(mark(X1),mark(X2)))
            
            mark#(plus(X1,X2)) = X1 + X2 + 1 >= X1 = mark#(X1)
            
            mark#(plus(X1,X2)) = X1 + X2 + 1 >= X2 = mark#(X2)
            
            active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
            
            mark#(U21(X1,X2,X3)) = 0 >= 0 = active#(U21(mark(X1),X2,X3))
            
            active#(and(tt(),X)) = X >= X = mark#(X)
            
            active#(U21(tt(),M,N)) = 0 >= 0 = mark#(s(plus(N,M)))
            
            active(U11(tt(),N)) = N >= N = mark(N)
            
            active(U21(tt(),M,N)) = 0 >= 0 = mark(s(plus(N,M)))
            
            active(and(tt(),X)) = X >= X = 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())) = N + 1 >= N = mark(U11(isNat(N),N))
            
            active(plus(N,s(M))) = N + 1 >= 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
            
            mark(U11(X1,X2)) = X2 >= X2 = active(U11(mark(X1),X2))
            
            mark(tt()) = 0 >= 0 = active(tt())
            
            mark(U21(X1,X2,X3)) = 0 >= 0 = active(U21(mark(X1),X2,X3))
            
            mark(s(X)) = 0 >= 0 = active(s(mark(X)))
            
            mark(plus(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(plus(mark(X1),mark(X2)))
            
            mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
            
            mark(isNat(X)) = 0 >= 0 = active(isNat(X))
            
            mark(0()) = 0 >= 0 = active(0())
            
            U11(mark(X1),X2) = X2 >= X2 = U11(X1,X2)
            
            U11(X1,mark(X2)) = X2 >= X2 = U11(X1,X2)
            
            U11(active(X1),X2) = X2 >= X2 = U11(X1,X2)
            
            U11(X1,active(X2)) = X2 >= X2 = U11(X1,X2)
            
            U21(mark(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
            
            U21(X1,mark(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
            
            U21(X1,X2,mark(X3)) = 0 >= 0 = U21(X1,X2,X3)
            
            U21(active(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
            
            U21(X1,active(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
            
            U21(X1,X2,active(X3)) = 0 >= 0 = U21(X1,X2,X3)
            
            s(mark(X)) = 0 >= 0 = s(X)
            
            s(active(X)) = 0 >= 0 = s(X)
            
            plus(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
            
            plus(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
            
            plus(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
            
            plus(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
            
            and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
            
            and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
            
            and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
            
            and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
             mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
             mark#(and(X1,X2)) -> mark#(X1)
             mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
             active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
             mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
             active#(and(tt(),X)) -> mark#(X)
             active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
            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)
           Matrix Interpretation Processor:
            dimension: 1
            interpretation:
             [mark#](x0) = x0,
             
             [active#](x0) = x0,
             
             [isNat](x0) = x0,
             
             [0] = 1,
             
             [and](x0, x1) = x0 + x1,
             
             [s](x0) = x0,
             
             [plus](x0, x1) = x0 + x1,
             
             [U21](x0, x1, x2) = x1 + x2,
             
             [mark](x0) = x0,
             
             [active](x0) = x0,
             
             [U11](x0, x1) = x1 + 1,
             
             [tt] = 1
            orientation:
             mark#(isNat(X)) = X >= X = active#(isNat(X))
             
             active#(isNat(s(V1))) = V1 >= V1 = mark#(isNat(V1))
             
             mark#(and(X1,X2)) = X1 + X2 >= X1 + X2 = active#(and(mark(X1),X2))
             
             mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
             
             mark#(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active#(plus(mark(X1),mark(X2)))
             
             active#(isNat(plus(V1,V2))) = V1 + V2 >= V1 + V2 = mark#(and(isNat(V1),isNat(V2)))
             
             mark#(U21(X1,X2,X3)) = X2 + X3 >= X2 + X3 = active#(U21(mark(X1),X2,X3))
             
             active#(and(tt(),X)) = X + 1 >= X = mark#(X)
             
             active#(U21(tt(),M,N)) = M + N >= M + N = mark#(s(plus(N,M)))
             
             active(U11(tt(),N)) = N + 1 >= N = mark(N)
             
             active(U21(tt(),M,N)) = M + N >= M + N = mark(s(plus(N,M)))
             
             active(and(tt(),X)) = X + 1 >= X = mark(X)
             
             active(isNat(0())) = 1 >= 1 = mark(tt())
             
             active(isNat(plus(V1,V2))) = V1 + V2 >= V1 + V2 = mark(and(isNat(V1),isNat(V2)))
             
             active(isNat(s(V1))) = V1 >= V1 = mark(isNat(V1))
             
             active(plus(N,0())) = N + 1 >= N + 1 = mark(U11(isNat(N),N))
             
             active(plus(N,s(M))) = M + N >= M + N = mark(U21(and(isNat(M),isNat(N)),M,N))
             
             mark(U11(X1,X2)) = X2 + 1 >= X2 + 1 = active(U11(mark(X1),X2))
             
             mark(tt()) = 1 >= 1 = active(tt())
             
             mark(U21(X1,X2,X3)) = X2 + X3 >= X2 + X3 = active(U21(mark(X1),X2,X3))
             
             mark(s(X)) = X >= X = active(s(mark(X)))
             
             mark(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active(plus(mark(X1),mark(X2)))
             
             mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
             
             mark(isNat(X)) = X >= X = active(isNat(X))
             
             mark(0()) = 1 >= 1 = active(0())
             
             U11(mark(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
             
             U11(X1,mark(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
             
             U11(active(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
             
             U11(X1,active(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
             
             U21(mark(X1),X2,X3) = X2 + X3 >= X2 + X3 = U21(X1,X2,X3)
             
             U21(X1,mark(X2),X3) = X2 + X3 >= X2 + X3 = U21(X1,X2,X3)
             
             U21(X1,X2,mark(X3)) = X2 + X3 >= X2 + X3 = U21(X1,X2,X3)
             
             U21(active(X1),X2,X3) = X2 + X3 >= X2 + X3 = U21(X1,X2,X3)
             
             U21(X1,active(X2),X3) = X2 + X3 >= X2 + X3 = U21(X1,X2,X3)
             
             U21(X1,X2,active(X3)) = X2 + X3 >= X2 + X3 = U21(X1,X2,X3)
             
             s(mark(X)) = X >= X = s(X)
             
             s(active(X)) = X >= X = s(X)
             
             plus(mark(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
             
             plus(X1,mark(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
             
             plus(active(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
             
             plus(X1,active(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
             
             and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
             
             and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
             
             and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
             
             and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
              mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
              mark#(and(X1,X2)) -> mark#(X1)
              mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
              active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
              mark#(U21(X1,X2,X3)) -> active#(U21(mark(X1),X2,X3))
              active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
             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)
            Matrix Interpretation Processor:
             dimension: 1
             interpretation:
              [mark#](x0) = x0,
              
              [active#](x0) = 0,
              
              [isNat](x0) = 0,
              
              [0] = 0,
              
              [and](x0, x1) = x0 + x1,
              
              [s](x0) = 0,
              
              [plus](x0, x1) = x0 + x1 + 1,
              
              [U21](x0, x1, x2) = 0,
              
              [mark](x0) = x0,
              
              [active](x0) = x0,
              
              [U11](x0, x1) = x1,
              
              [tt] = 0
             orientation:
              mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
              
              active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
              
              mark#(and(X1,X2)) = X1 + X2 >= 0 = active#(and(mark(X1),X2))
              
              mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
              
              mark#(plus(X1,X2)) = X1 + X2 + 1 >= 0 = active#(plus(mark(X1),mark(X2)))
              
              active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
              
              mark#(U21(X1,X2,X3)) = 0 >= 0 = active#(U21(mark(X1),X2,X3))
              
              active#(U21(tt(),M,N)) = 0 >= 0 = mark#(s(plus(N,M)))
              
              active(U11(tt(),N)) = N >= N = mark(N)
              
              active(U21(tt(),M,N)) = 0 >= 0 = mark(s(plus(N,M)))
              
              active(and(tt(),X)) = X >= X = 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())) = N + 1 >= N = mark(U11(isNat(N),N))
              
              active(plus(N,s(M))) = N + 1 >= 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
              
              mark(U11(X1,X2)) = X2 >= X2 = active(U11(mark(X1),X2))
              
              mark(tt()) = 0 >= 0 = active(tt())
              
              mark(U21(X1,X2,X3)) = 0 >= 0 = active(U21(mark(X1),X2,X3))
              
              mark(s(X)) = 0 >= 0 = active(s(mark(X)))
              
              mark(plus(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(plus(mark(X1),mark(X2)))
              
              mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
              
              mark(isNat(X)) = 0 >= 0 = active(isNat(X))
              
              mark(0()) = 0 >= 0 = active(0())
              
              U11(mark(X1),X2) = X2 >= X2 = U11(X1,X2)
              
              U11(X1,mark(X2)) = X2 >= X2 = U11(X1,X2)
              
              U11(active(X1),X2) = X2 >= X2 = U11(X1,X2)
              
              U11(X1,active(X2)) = X2 >= X2 = U11(X1,X2)
              
              U21(mark(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
              
              U21(X1,mark(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
              
              U21(X1,X2,mark(X3)) = 0 >= 0 = U21(X1,X2,X3)
              
              U21(active(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
              
              U21(X1,active(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
              
              U21(X1,X2,active(X3)) = 0 >= 0 = U21(X1,X2,X3)
              
              s(mark(X)) = 0 >= 0 = s(X)
              
              s(active(X)) = 0 >= 0 = s(X)
              
              plus(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
              
              plus(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
              
              plus(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
              
              plus(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
              
              and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
              
              and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
              
              and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
              
              and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
               mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
               mark#(and(X1,X2)) -> 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#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
              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)
             Matrix Interpretation Processor:
              dimension: 1
              interpretation:
               [mark#](x0) = x0,
               
               [active#](x0) = 0,
               
               [isNat](x0) = 0,
               
               [0] = 1,
               
               [and](x0, x1) = x0 + x1,
               
               [s](x0) = 0,
               
               [plus](x0, x1) = x0 + 1,
               
               [U21](x0, x1, x2) = x2 + 1,
               
               [mark](x0) = x0,
               
               [active](x0) = x0,
               
               [U11](x0, x1) = x1 + 1,
               
               [tt] = 0
              orientation:
               mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
               
               active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
               
               mark#(and(X1,X2)) = X1 + X2 >= 0 = active#(and(mark(X1),X2))
               
               mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
               
               active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
               
               mark#(U21(X1,X2,X3)) = X3 + 1 >= 0 = active#(U21(mark(X1),X2,X3))
               
               active#(U21(tt(),M,N)) = 0 >= 0 = mark#(s(plus(N,M)))
               
               active(U11(tt(),N)) = N + 1 >= N = mark(N)
               
               active(U21(tt(),M,N)) = N + 1 >= 0 = mark(s(plus(N,M)))
               
               active(and(tt(),X)) = X >= X = 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())) = N + 1 >= N + 1 = mark(U11(isNat(N),N))
               
               active(plus(N,s(M))) = N + 1 >= N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
               
               mark(U11(X1,X2)) = X2 + 1 >= X2 + 1 = active(U11(mark(X1),X2))
               
               mark(tt()) = 0 >= 0 = active(tt())
               
               mark(U21(X1,X2,X3)) = X3 + 1 >= X3 + 1 = active(U21(mark(X1),X2,X3))
               
               mark(s(X)) = 0 >= 0 = active(s(mark(X)))
               
               mark(plus(X1,X2)) = X1 + 1 >= X1 + 1 = active(plus(mark(X1),mark(X2)))
               
               mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
               
               mark(isNat(X)) = 0 >= 0 = active(isNat(X))
               
               mark(0()) = 1 >= 1 = active(0())
               
               U11(mark(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
               
               U11(X1,mark(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
               
               U11(active(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
               
               U11(X1,active(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
               
               U21(mark(X1),X2,X3) = X3 + 1 >= X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,mark(X2),X3) = X3 + 1 >= X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,X2,mark(X3)) = X3 + 1 >= X3 + 1 = U21(X1,X2,X3)
               
               U21(active(X1),X2,X3) = X3 + 1 >= X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,active(X2),X3) = X3 + 1 >= X3 + 1 = U21(X1,X2,X3)
               
               U21(X1,X2,active(X3)) = X3 + 1 >= X3 + 1 = U21(X1,X2,X3)
               
               s(mark(X)) = 0 >= 0 = s(X)
               
               s(active(X)) = 0 >= 0 = s(X)
               
               plus(mark(X1),X2) = X1 + 1 >= X1 + 1 = plus(X1,X2)
               
               plus(X1,mark(X2)) = X1 + 1 >= X1 + 1 = plus(X1,X2)
               
               plus(active(X1),X2) = X1 + 1 >= X1 + 1 = plus(X1,X2)
               
               plus(X1,active(X2)) = X1 + 1 >= X1 + 1 = plus(X1,X2)
               
               and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
               
               and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
               
               and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
               
               and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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(s(V1))) -> mark#(isNat(V1))
                mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
                mark#(and(X1,X2)) -> mark#(X1)
                active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
                active#(U21(tt(),M,N)) -> mark#(s(plus(N,M)))
               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)
              Matrix Interpretation Processor:
               dimension: 1
               interpretation:
                [mark#](x0) = 0,
                
                [active#](x0) = x0,
                
                [isNat](x0) = 0,
                
                [0] = 0,
                
                [and](x0, x1) = 0,
                
                [s](x0) = 0,
                
                [plus](x0, x1) = 0,
                
                [U21](x0, x1, x2) = 1,
                
                [mark](x0) = 0,
                
                [active](x0) = 0,
                
                [U11](x0, x1) = 0,
                
                [tt] = 0
               orientation:
                mark#(isNat(X)) = 0 >= 0 = active#(isNat(X))
                
                active#(isNat(s(V1))) = 0 >= 0 = mark#(isNat(V1))
                
                mark#(and(X1,X2)) = 0 >= 0 = active#(and(mark(X1),X2))
                
                mark#(and(X1,X2)) = 0 >= 0 = mark#(X1)
                
                active#(isNat(plus(V1,V2))) = 0 >= 0 = mark#(and(isNat(V1),isNat(V2)))
                
                active#(U21(tt(),M,N)) = 1 >= 0 = mark#(s(plus(N,M)))
                
                active(U11(tt(),N)) = 0 >= 0 = mark(N)
                
                active(U21(tt(),M,N)) = 0 >= 0 = mark(s(plus(N,M)))
                
                active(and(tt(),X)) = 0 >= 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())) = 0 >= 0 = mark(U11(isNat(N),N))
                
                active(plus(N,s(M))) = 0 >= 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
                
                mark(U11(X1,X2)) = 0 >= 0 = active(U11(mark(X1),X2))
                
                mark(tt()) = 0 >= 0 = active(tt())
                
                mark(U21(X1,X2,X3)) = 0 >= 0 = active(U21(mark(X1),X2,X3))
                
                mark(s(X)) = 0 >= 0 = active(s(mark(X)))
                
                mark(plus(X1,X2)) = 0 >= 0 = active(plus(mark(X1),mark(X2)))
                
                mark(and(X1,X2)) = 0 >= 0 = active(and(mark(X1),X2))
                
                mark(isNat(X)) = 0 >= 0 = active(isNat(X))
                
                mark(0()) = 0 >= 0 = active(0())
                
                U11(mark(X1),X2) = 0 >= 0 = U11(X1,X2)
                
                U11(X1,mark(X2)) = 0 >= 0 = U11(X1,X2)
                
                U11(active(X1),X2) = 0 >= 0 = U11(X1,X2)
                
                U11(X1,active(X2)) = 0 >= 0 = U11(X1,X2)
                
                U21(mark(X1),X2,X3) = 1 >= 1 = U21(X1,X2,X3)
                
                U21(X1,mark(X2),X3) = 1 >= 1 = U21(X1,X2,X3)
                
                U21(X1,X2,mark(X3)) = 1 >= 1 = U21(X1,X2,X3)
                
                U21(active(X1),X2,X3) = 1 >= 1 = U21(X1,X2,X3)
                
                U21(X1,active(X2),X3) = 1 >= 1 = U21(X1,X2,X3)
                
                U21(X1,X2,active(X3)) = 1 >= 1 = U21(X1,X2,X3)
                
                s(mark(X)) = 0 >= 0 = s(X)
                
                s(active(X)) = 0 >= 0 = s(X)
                
                plus(mark(X1),X2) = 0 >= 0 = plus(X1,X2)
                
                plus(X1,mark(X2)) = 0 >= 0 = plus(X1,X2)
                
                plus(active(X1),X2) = 0 >= 0 = plus(X1,X2)
                
                plus(X1,active(X2)) = 0 >= 0 = plus(X1,X2)
                
                and(mark(X1),X2) = 0 >= 0 = and(X1,X2)
                
                and(X1,mark(X2)) = 0 >= 0 = and(X1,X2)
                
                and(active(X1),X2) = 0 >= 0 = and(X1,X2)
                
                and(X1,active(X2)) = 0 >= 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(s(V1))) -> mark#(isNat(V1))
                 mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
                 mark#(and(X1,X2)) -> mark#(X1)
                 active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
                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)
               Matrix Interpretation Processor:
                dimension: 1
                interpretation:
                 [mark#](x0) = 1,
                 
                 [active#](x0) = x0,
                 
                 [isNat](x0) = 1,
                 
                 [0] = 0,
                 
                 [and](x0, x1) = 0,
                 
                 [s](x0) = 0,
                 
                 [plus](x0, x1) = 1,
                 
                 [U21](x0, x1, x2) = 0,
                 
                 [mark](x0) = 0,
                 
                 [active](x0) = 0,
                 
                 [U11](x0, x1) = 0,
                 
                 [tt] = 0
                orientation:
                 mark#(isNat(X)) = 1 >= 1 = active#(isNat(X))
                 
                 active#(isNat(s(V1))) = 1 >= 1 = mark#(isNat(V1))
                 
                 mark#(and(X1,X2)) = 1 >= 0 = active#(and(mark(X1),X2))
                 
                 mark#(and(X1,X2)) = 1 >= 1 = mark#(X1)
                 
                 active#(isNat(plus(V1,V2))) = 1 >= 1 = mark#(and(isNat(V1),isNat(V2)))
                 
                 active(U11(tt(),N)) = 0 >= 0 = mark(N)
                 
                 active(U21(tt(),M,N)) = 0 >= 0 = mark(s(plus(N,M)))
                 
                 active(and(tt(),X)) = 0 >= 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())) = 0 >= 0 = mark(U11(isNat(N),N))
                 
                 active(plus(N,s(M))) = 0 >= 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
                 
                 mark(U11(X1,X2)) = 0 >= 0 = active(U11(mark(X1),X2))
                 
                 mark(tt()) = 0 >= 0 = active(tt())
                 
                 mark(U21(X1,X2,X3)) = 0 >= 0 = active(U21(mark(X1),X2,X3))
                 
                 mark(s(X)) = 0 >= 0 = active(s(mark(X)))
                 
                 mark(plus(X1,X2)) = 0 >= 0 = active(plus(mark(X1),mark(X2)))
                 
                 mark(and(X1,X2)) = 0 >= 0 = active(and(mark(X1),X2))
                 
                 mark(isNat(X)) = 0 >= 0 = active(isNat(X))
                 
                 mark(0()) = 0 >= 0 = active(0())
                 
                 U11(mark(X1),X2) = 0 >= 0 = U11(X1,X2)
                 
                 U11(X1,mark(X2)) = 0 >= 0 = U11(X1,X2)
                 
                 U11(active(X1),X2) = 0 >= 0 = U11(X1,X2)
                 
                 U11(X1,active(X2)) = 0 >= 0 = U11(X1,X2)
                 
                 U21(mark(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
                 
                 U21(X1,mark(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
                 
                 U21(X1,X2,mark(X3)) = 0 >= 0 = U21(X1,X2,X3)
                 
                 U21(active(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
                 
                 U21(X1,active(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
                 
                 U21(X1,X2,active(X3)) = 0 >= 0 = U21(X1,X2,X3)
                 
                 s(mark(X)) = 0 >= 0 = s(X)
                 
                 s(active(X)) = 0 >= 0 = s(X)
                 
                 plus(mark(X1),X2) = 1 >= 1 = plus(X1,X2)
                 
                 plus(X1,mark(X2)) = 1 >= 1 = plus(X1,X2)
                 
                 plus(active(X1),X2) = 1 >= 1 = plus(X1,X2)
                 
                 plus(X1,active(X2)) = 1 >= 1 = plus(X1,X2)
                 
                 and(mark(X1),X2) = 0 >= 0 = and(X1,X2)
                 
                 and(X1,mark(X2)) = 0 >= 0 = and(X1,X2)
                 
                 and(active(X1),X2) = 0 >= 0 = and(X1,X2)
                 
                 and(X1,active(X2)) = 0 >= 0 = and(X1,X2)
                 
                 isNat(mark(X)) = 1 >= 1 = isNat(X)
                 
                 isNat(active(X)) = 1 >= 1 = isNat(X)
                problem:
                 DPs:
                  mark#(isNat(X)) -> active#(isNat(X))
                  active#(isNat(s(V1))) -> mark#(isNat(V1))
                  mark#(and(X1,X2)) -> mark#(X1)
                  active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
                 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)
                Matrix Interpretation Processor:
                 dimension: 1
                 interpretation:
                  [mark#](x0) = x0,
                  
                  [active#](x0) = x0,
                  
                  [isNat](x0) = x0,
                  
                  [0] = 1,
                  
                  [and](x0, x1) = x0 + x1,
                  
                  [s](x0) = x0 + 1,
                  
                  [plus](x0, x1) = x0 + x1,
                  
                  [U21](x0, x1, x2) = x1 + x2 + 1,
                  
                  [mark](x0) = x0,
                  
                  [active](x0) = x0,
                  
                  [U11](x0, x1) = x1 + 1,
                  
                  [tt] = 0
                 orientation:
                  mark#(isNat(X)) = X >= X = active#(isNat(X))
                  
                  active#(isNat(s(V1))) = V1 + 1 >= V1 = mark#(isNat(V1))
                  
                  mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
                  
                  active#(isNat(plus(V1,V2))) = V1 + V2 >= V1 + V2 = mark#(and(isNat(V1),isNat(V2)))
                  
                  active(U11(tt(),N)) = N + 1 >= N = mark(N)
                  
                  active(U21(tt(),M,N)) = M + N + 1 >= M + N + 1 = mark(s(plus(N,M)))
                  
                  active(and(tt(),X)) = X >= X = mark(X)
                  
                  active(isNat(0())) = 1 >= 0 = mark(tt())
                  
                  active(isNat(plus(V1,V2))) = V1 + V2 >= V1 + V2 = mark(and(isNat(V1),isNat(V2)))
                  
                  active(isNat(s(V1))) = V1 + 1 >= V1 = mark(isNat(V1))
                  
                  active(plus(N,0())) = N + 1 >= N + 1 = mark(U11(isNat(N),N))
                  
                  active(plus(N,s(M))) = M + N + 1 >= M + N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
                  
                  mark(U11(X1,X2)) = X2 + 1 >= X2 + 1 = active(U11(mark(X1),X2))
                  
                  mark(tt()) = 0 >= 0 = active(tt())
                  
                  mark(U21(X1,X2,X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = active(U21(mark(X1),X2,X3))
                  
                  mark(s(X)) = X + 1 >= X + 1 = active(s(mark(X)))
                  
                  mark(plus(X1,X2)) = X1 + X2 >= X1 + X2 = active(plus(mark(X1),mark(X2)))
                  
                  mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
                  
                  mark(isNat(X)) = X >= X = active(isNat(X))
                  
                  mark(0()) = 1 >= 1 = active(0())
                  
                  U11(mark(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                  
                  U11(X1,mark(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                  
                  U11(active(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                  
                  U11(X1,active(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                  
                  U21(mark(X1),X2,X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                  
                  U21(X1,mark(X2),X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                  
                  U21(X1,X2,mark(X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                  
                  U21(active(X1),X2,X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                  
                  U21(X1,active(X2),X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                  
                  U21(X1,X2,active(X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                  
                  s(mark(X)) = X + 1 >= X + 1 = s(X)
                  
                  s(active(X)) = X + 1 >= X + 1 = s(X)
                  
                  plus(mark(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
                  
                  plus(X1,mark(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
                  
                  plus(active(X1),X2) = X1 + X2 >= X1 + X2 = plus(X1,X2)
                  
                  plus(X1,active(X2)) = X1 + X2 >= X1 + X2 = plus(X1,X2)
                  
                  and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
                  
                  and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
                  
                  and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
                  
                  and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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))
                   mark#(and(X1,X2)) -> mark#(X1)
                   active#(isNat(plus(V1,V2))) -> mark#(and(isNat(V1),isNat(V2)))
                  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)
                 Matrix Interpretation Processor:
                  dimension: 1
                  interpretation:
                   [mark#](x0) = x0,
                   
                   [active#](x0) = x0,
                   
                   [isNat](x0) = x0,
                   
                   [0] = 1,
                   
                   [and](x0, x1) = x0 + x1,
                   
                   [s](x0) = x0,
                   
                   [plus](x0, x1) = x0 + x1 + 1,
                   
                   [U21](x0, x1, x2) = x1 + x2 + 1,
                   
                   [mark](x0) = x0,
                   
                   [active](x0) = x0,
                   
                   [U11](x0, x1) = x1 + 1,
                   
                   [tt] = 1
                  orientation:
                   mark#(isNat(X)) = X >= X = active#(isNat(X))
                   
                   mark#(and(X1,X2)) = X1 + X2 >= X1 = mark#(X1)
                   
                   active#(isNat(plus(V1,V2))) = V1 + V2 + 1 >= V1 + V2 = mark#(and(isNat(V1),isNat(V2)))
                   
                   active(U11(tt(),N)) = N + 1 >= N = mark(N)
                   
                   active(U21(tt(),M,N)) = M + N + 1 >= M + N + 1 = mark(s(plus(N,M)))
                   
                   active(and(tt(),X)) = X + 1 >= X = mark(X)
                   
                   active(isNat(0())) = 1 >= 1 = mark(tt())
                   
                   active(isNat(plus(V1,V2))) = V1 + V2 + 1 >= V1 + V2 = mark(and(isNat(V1),isNat(V2)))
                   
                   active(isNat(s(V1))) = V1 >= V1 = mark(isNat(V1))
                   
                   active(plus(N,0())) = N + 2 >= N + 1 = mark(U11(isNat(N),N))
                   
                   active(plus(N,s(M))) = M + N + 1 >= M + N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
                   
                   mark(U11(X1,X2)) = X2 + 1 >= X2 + 1 = active(U11(mark(X1),X2))
                   
                   mark(tt()) = 1 >= 1 = active(tt())
                   
                   mark(U21(X1,X2,X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = active(U21(mark(X1),X2,X3))
                   
                   mark(s(X)) = X >= X = active(s(mark(X)))
                   
                   mark(plus(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(plus(mark(X1),mark(X2)))
                   
                   mark(and(X1,X2)) = X1 + X2 >= X1 + X2 = active(and(mark(X1),X2))
                   
                   mark(isNat(X)) = X >= X = active(isNat(X))
                   
                   mark(0()) = 1 >= 1 = active(0())
                   
                   U11(mark(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                   
                   U11(X1,mark(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                   
                   U11(active(X1),X2) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                   
                   U11(X1,active(X2)) = X2 + 1 >= X2 + 1 = U11(X1,X2)
                   
                   U21(mark(X1),X2,X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                   
                   U21(X1,mark(X2),X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                   
                   U21(X1,X2,mark(X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                   
                   U21(active(X1),X2,X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                   
                   U21(X1,active(X2),X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                   
                   U21(X1,X2,active(X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                   
                   s(mark(X)) = X >= X = s(X)
                   
                   s(active(X)) = X >= X = s(X)
                   
                   plus(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                   
                   plus(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                   
                   plus(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                   
                   plus(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                   
                   and(mark(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
                   
                   and(X1,mark(X2)) = X1 + X2 >= X1 + X2 = and(X1,X2)
                   
                   and(active(X1),X2) = X1 + X2 >= X1 + X2 = and(X1,X2)
                   
                   and(X1,active(X2)) = X1 + X2 >= X1 + X2 = 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))
                    mark#(and(X1,X2)) -> mark#(X1)
                   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)
                  Matrix Interpretation Processor:
                   dimension: 1
                   interpretation:
                    [mark#](x0) = 1,
                    
                    [active#](x0) = 0,
                    
                    [isNat](x0) = 0,
                    
                    [0] = 0,
                    
                    [and](x0, x1) = 0,
                    
                    [s](x0) = 0,
                    
                    [plus](x0, x1) = 0,
                    
                    [U21](x0, x1, x2) = 0,
                    
                    [mark](x0) = 0,
                    
                    [active](x0) = 0,
                    
                    [U11](x0, x1) = 0,
                    
                    [tt] = 0
                   orientation:
                    mark#(isNat(X)) = 1 >= 0 = active#(isNat(X))
                    
                    mark#(and(X1,X2)) = 1 >= 1 = mark#(X1)
                    
                    active(U11(tt(),N)) = 0 >= 0 = mark(N)
                    
                    active(U21(tt(),M,N)) = 0 >= 0 = mark(s(plus(N,M)))
                    
                    active(and(tt(),X)) = 0 >= 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())) = 0 >= 0 = mark(U11(isNat(N),N))
                    
                    active(plus(N,s(M))) = 0 >= 0 = mark(U21(and(isNat(M),isNat(N)),M,N))
                    
                    mark(U11(X1,X2)) = 0 >= 0 = active(U11(mark(X1),X2))
                    
                    mark(tt()) = 0 >= 0 = active(tt())
                    
                    mark(U21(X1,X2,X3)) = 0 >= 0 = active(U21(mark(X1),X2,X3))
                    
                    mark(s(X)) = 0 >= 0 = active(s(mark(X)))
                    
                    mark(plus(X1,X2)) = 0 >= 0 = active(plus(mark(X1),mark(X2)))
                    
                    mark(and(X1,X2)) = 0 >= 0 = active(and(mark(X1),X2))
                    
                    mark(isNat(X)) = 0 >= 0 = active(isNat(X))
                    
                    mark(0()) = 0 >= 0 = active(0())
                    
                    U11(mark(X1),X2) = 0 >= 0 = U11(X1,X2)
                    
                    U11(X1,mark(X2)) = 0 >= 0 = U11(X1,X2)
                    
                    U11(active(X1),X2) = 0 >= 0 = U11(X1,X2)
                    
                    U11(X1,active(X2)) = 0 >= 0 = U11(X1,X2)
                    
                    U21(mark(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
                    
                    U21(X1,mark(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
                    
                    U21(X1,X2,mark(X3)) = 0 >= 0 = U21(X1,X2,X3)
                    
                    U21(active(X1),X2,X3) = 0 >= 0 = U21(X1,X2,X3)
                    
                    U21(X1,active(X2),X3) = 0 >= 0 = U21(X1,X2,X3)
                    
                    U21(X1,X2,active(X3)) = 0 >= 0 = U21(X1,X2,X3)
                    
                    s(mark(X)) = 0 >= 0 = s(X)
                    
                    s(active(X)) = 0 >= 0 = s(X)
                    
                    plus(mark(X1),X2) = 0 >= 0 = plus(X1,X2)
                    
                    plus(X1,mark(X2)) = 0 >= 0 = plus(X1,X2)
                    
                    plus(active(X1),X2) = 0 >= 0 = plus(X1,X2)
                    
                    plus(X1,active(X2)) = 0 >= 0 = plus(X1,X2)
                    
                    and(mark(X1),X2) = 0 >= 0 = and(X1,X2)
                    
                    and(X1,mark(X2)) = 0 >= 0 = and(X1,X2)
                    
                    and(active(X1),X2) = 0 >= 0 = and(X1,X2)
                    
                    and(X1,active(X2)) = 0 >= 0 = and(X1,X2)
                    
                    isNat(mark(X)) = 0 >= 0 = isNat(X)
                    
                    isNat(active(X)) = 0 >= 0 = isNat(X)
                   problem:
                    DPs:
                     mark#(and(X1,X2)) -> mark#(X1)
                    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)
                   Matrix Interpretation Processor:
                    dimension: 1
                    interpretation:
                     [mark#](x0) = x0 + 1,
                     
                     [isNat](x0) = x0,
                     
                     [0] = 0,
                     
                     [and](x0, x1) = x0 + x1 + 1,
                     
                     [s](x0) = x0,
                     
                     [plus](x0, x1) = x0 + x1 + 1,
                     
                     [U21](x0, x1, x2) = x1 + x2 + 1,
                     
                     [mark](x0) = x0,
                     
                     [active](x0) = x0,
                     
                     [U11](x0, x1) = x1,
                     
                     [tt] = 0
                    orientation:
                     mark#(and(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = mark#(X1)
                     
                     active(U11(tt(),N)) = N >= N = mark(N)
                     
                     active(U21(tt(),M,N)) = M + N + 1 >= M + N + 1 = mark(s(plus(N,M)))
                     
                     active(and(tt(),X)) = X + 1 >= X = mark(X)
                     
                     active(isNat(0())) = 0 >= 0 = mark(tt())
                     
                     active(isNat(plus(V1,V2))) = V1 + V2 + 1 >= V1 + V2 + 1 = mark(and(isNat(V1),isNat(V2)))
                     
                     active(isNat(s(V1))) = V1 >= V1 = mark(isNat(V1))
                     
                     active(plus(N,0())) = N + 1 >= N = mark(U11(isNat(N),N))
                     
                     active(plus(N,s(M))) = M + N + 1 >= M + N + 1 = mark(U21(and(isNat(M),isNat(N)),M,N))
                     
                     mark(U11(X1,X2)) = X2 >= X2 = active(U11(mark(X1),X2))
                     
                     mark(tt()) = 0 >= 0 = active(tt())
                     
                     mark(U21(X1,X2,X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = active(U21(mark(X1),X2,X3))
                     
                     mark(s(X)) = X >= X = active(s(mark(X)))
                     
                     mark(plus(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(plus(mark(X1),mark(X2)))
                     
                     mark(and(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(and(mark(X1),X2))
                     
                     mark(isNat(X)) = X >= X = active(isNat(X))
                     
                     mark(0()) = 0 >= 0 = active(0())
                     
                     U11(mark(X1),X2) = X2 >= X2 = U11(X1,X2)
                     
                     U11(X1,mark(X2)) = X2 >= X2 = U11(X1,X2)
                     
                     U11(active(X1),X2) = X2 >= X2 = U11(X1,X2)
                     
                     U11(X1,active(X2)) = X2 >= X2 = U11(X1,X2)
                     
                     U21(mark(X1),X2,X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                     
                     U21(X1,mark(X2),X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                     
                     U21(X1,X2,mark(X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                     
                     U21(active(X1),X2,X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                     
                     U21(X1,active(X2),X3) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                     
                     U21(X1,X2,active(X3)) = X2 + X3 + 1 >= X2 + X3 + 1 = U21(X1,X2,X3)
                     
                     s(mark(X)) = X >= X = s(X)
                     
                     s(active(X)) = X >= X = s(X)
                     
                     plus(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                     
                     plus(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                     
                     plus(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                     
                     plus(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = plus(X1,X2)
                     
                     and(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2)
                     
                     and(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2)
                     
                     and(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2)
                     
                     and(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2)
                     
                     isNat(mark(X)) = X >= X = isNat(X)
                     
                     isNat(active(X)) = X >= X = isNat(X)
                    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:
      plus#(mark(X1),X2) -> plus#(X1,X2)
      plus#(X1,active(X2)) -> plus#(X1,X2)
      plus#(active(X1),X2) -> plus#(X1,X2)
      plus#(X1,mark(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)
     Open
     
     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)
     Open
     
     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)
     Open
     
     DPs:
      and#(mark(X1),X2) -> and#(X1,X2)
      and#(X1,active(X2)) -> and#(X1,X2)
      and#(active(X1),X2) -> and#(X1,X2)
      and#(X1,mark(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)
     Open
     
     DPs:
      U11#(mark(X1),X2) -> U11#(X1,X2)
      U11#(X1,active(X2)) -> U11#(X1,X2)
      U11#(active(X1),X2) -> U11#(X1,X2)
      U11#(X1,mark(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)
     Open
     
     DPs:
      U21#(mark(X1),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#(active(X1),X2,X3) -> U21#(X1,X2,X3)
      U21#(X1,X2,mark(X3)) -> U21#(X1,X2,X3)
      U21#(X1,mark(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)
     Open