YES

Problem:
 __(__(X,Y),Z) -> __(X,__(Y,Z))
 __(X,nil()) -> X
 __(nil(),X) -> X
 and(tt(),X) -> activate(X)
 isList(V) -> isNeList(activate(V))
 isList(n__nil()) -> tt()
 isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
 isNeList(V) -> isQid(activate(V))
 isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
 isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
 isNePal(V) -> isQid(activate(V))
 isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
 isPal(V) -> isNePal(activate(V))
 isPal(n__nil()) -> tt()
 isQid(n__a()) -> tt()
 isQid(n__e()) -> tt()
 isQid(n__i()) -> tt()
 isQid(n__o()) -> tt()
 isQid(n__u()) -> tt()
 nil() -> n__nil()
 __(X1,X2) -> n____(X1,X2)
 isList(X) -> n__isList(X)
 isNeList(X) -> n__isNeList(X)
 isPal(X) -> n__isPal(X)
 a() -> n__a()
 e() -> n__e()
 i() -> n__i()
 o() -> n__o()
 u() -> n__u()
 activate(n__nil()) -> nil()
 activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
 activate(n__isList(X)) -> isList(X)
 activate(n__isNeList(X)) -> isNeList(X)
 activate(n__isPal(X)) -> isPal(X)
 activate(n__a()) -> a()
 activate(n__e()) -> e()
 activate(n__i()) -> i()
 activate(n__o()) -> o()
 activate(n__u()) -> u()
 activate(X) -> X

Proof:
 DP Processor:
  DPs:
   __#(__(X,Y),Z) -> __#(Y,Z)
   __#(__(X,Y),Z) -> __#(X,__(Y,Z))
   and#(tt(),X) -> activate#(X)
   isList#(V) -> activate#(V)
   isList#(V) -> isNeList#(activate(V))
   isList#(n____(V1,V2)) -> activate#(V2)
   isList#(n____(V1,V2)) -> activate#(V1)
   isList#(n____(V1,V2)) -> isList#(activate(V1))
   isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
   isNeList#(V) -> activate#(V)
   isNeList#(V) -> isQid#(activate(V))
   isNeList#(n____(V1,V2)) -> activate#(V2)
   isNeList#(n____(V1,V2)) -> activate#(V1)
   isNeList#(n____(V1,V2)) -> isList#(activate(V1))
   isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
   isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
   isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
   isNePal#(V) -> activate#(V)
   isNePal#(V) -> isQid#(activate(V))
   isNePal#(n____(I,n____(P,I))) -> activate#(P)
   isNePal#(n____(I,n____(P,I))) -> activate#(I)
   isNePal#(n____(I,n____(P,I))) -> isQid#(activate(I))
   isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P)))
   isPal#(V) -> activate#(V)
   isPal#(V) -> isNePal#(activate(V))
   activate#(n__nil()) -> nil#()
   activate#(n____(X1,X2)) -> activate#(X2)
   activate#(n____(X1,X2)) -> activate#(X1)
   activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
   activate#(n__isList(X)) -> isList#(X)
   activate#(n__isNeList(X)) -> isNeList#(X)
   activate#(n__isPal(X)) -> isPal#(X)
   activate#(n__a()) -> a#()
   activate#(n__e()) -> e#()
   activate#(n__i()) -> i#()
   activate#(n__o()) -> o#()
   activate#(n__u()) -> u#()
  TRS:
   __(__(X,Y),Z) -> __(X,__(Y,Z))
   __(X,nil()) -> X
   __(nil(),X) -> X
   and(tt(),X) -> activate(X)
   isList(V) -> isNeList(activate(V))
   isList(n__nil()) -> tt()
   isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
   isNeList(V) -> isQid(activate(V))
   isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
   isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
   isNePal(V) -> isQid(activate(V))
   isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
   isPal(V) -> isNePal(activate(V))
   isPal(n__nil()) -> tt()
   isQid(n__a()) -> tt()
   isQid(n__e()) -> tt()
   isQid(n__i()) -> tt()
   isQid(n__o()) -> tt()
   isQid(n__u()) -> tt()
   nil() -> n__nil()
   __(X1,X2) -> n____(X1,X2)
   isList(X) -> n__isList(X)
   isNeList(X) -> n__isNeList(X)
   isPal(X) -> n__isPal(X)
   a() -> n__a()
   e() -> n__e()
   i() -> n__i()
   o() -> n__o()
   u() -> n__u()
   activate(n__nil()) -> nil()
   activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
   activate(n__isList(X)) -> isList(X)
   activate(n__isNeList(X)) -> isNeList(X)
   activate(n__isPal(X)) -> isPal(X)
   activate(n__a()) -> a()
   activate(n__e()) -> e()
   activate(n__i()) -> i()
   activate(n__o()) -> o()
   activate(n__u()) -> u()
   activate(X) -> X
  TDG Processor:
   DPs:
    __#(__(X,Y),Z) -> __#(Y,Z)
    __#(__(X,Y),Z) -> __#(X,__(Y,Z))
    and#(tt(),X) -> activate#(X)
    isList#(V) -> activate#(V)
    isList#(V) -> isNeList#(activate(V))
    isList#(n____(V1,V2)) -> activate#(V2)
    isList#(n____(V1,V2)) -> activate#(V1)
    isList#(n____(V1,V2)) -> isList#(activate(V1))
    isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
    isNeList#(V) -> activate#(V)
    isNeList#(V) -> isQid#(activate(V))
    isNeList#(n____(V1,V2)) -> activate#(V2)
    isNeList#(n____(V1,V2)) -> activate#(V1)
    isNeList#(n____(V1,V2)) -> isList#(activate(V1))
    isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
    isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
    isNePal#(V) -> activate#(V)
    isNePal#(V) -> isQid#(activate(V))
    isNePal#(n____(I,n____(P,I))) -> activate#(P)
    isNePal#(n____(I,n____(P,I))) -> activate#(I)
    isNePal#(n____(I,n____(P,I))) -> isQid#(activate(I))
    isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P)))
    isPal#(V) -> activate#(V)
    isPal#(V) -> isNePal#(activate(V))
    activate#(n__nil()) -> nil#()
    activate#(n____(X1,X2)) -> activate#(X2)
    activate#(n____(X1,X2)) -> activate#(X1)
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    activate#(n__isList(X)) -> isList#(X)
    activate#(n__isNeList(X)) -> isNeList#(X)
    activate#(n__isPal(X)) -> isPal#(X)
    activate#(n__a()) -> a#()
    activate#(n__e()) -> e#()
    activate#(n__i()) -> i#()
    activate#(n__o()) -> o#()
    activate#(n__u()) -> u#()
   TRS:
    __(__(X,Y),Z) -> __(X,__(Y,Z))
    __(X,nil()) -> X
    __(nil(),X) -> X
    and(tt(),X) -> activate(X)
    isList(V) -> isNeList(activate(V))
    isList(n__nil()) -> tt()
    isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
    isNeList(V) -> isQid(activate(V))
    isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
    isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
    isNePal(V) -> isQid(activate(V))
    isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
    isPal(V) -> isNePal(activate(V))
    isPal(n__nil()) -> tt()
    isQid(n__a()) -> tt()
    isQid(n__e()) -> tt()
    isQid(n__i()) -> tt()
    isQid(n__o()) -> tt()
    isQid(n__u()) -> tt()
    nil() -> n__nil()
    __(X1,X2) -> n____(X1,X2)
    isList(X) -> n__isList(X)
    isNeList(X) -> n__isNeList(X)
    isPal(X) -> n__isPal(X)
    a() -> n__a()
    e() -> n__e()
    i() -> n__i()
    o() -> n__o()
    u() -> n__u()
    activate(n__nil()) -> nil()
    activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
    activate(n__isList(X)) -> isList(X)
    activate(n__isNeList(X)) -> isNeList(X)
    activate(n__isPal(X)) -> isPal(X)
    activate(n__a()) -> a()
    activate(n__e()) -> e()
    activate(n__i()) -> i()
    activate(n__o()) -> o()
    activate(n__u()) -> u()
    activate(X) -> X
   graph:
    isPal#(V) -> isNePal#(activate(V)) ->
    isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P)))
    isPal#(V) -> isNePal#(activate(V)) ->
    isNePal#(n____(I,n____(P,I))) -> isQid#(activate(I))
    isPal#(V) -> isNePal#(activate(V)) ->
    isNePal#(n____(I,n____(P,I))) -> activate#(I)
    isPal#(V) -> isNePal#(activate(V)) ->
    isNePal#(n____(I,n____(P,I))) -> activate#(P)
    isPal#(V) -> isNePal#(activate(V)) ->
    isNePal#(V) -> isQid#(activate(V))
    isPal#(V) -> isNePal#(activate(V)) -> isNePal#(V) -> activate#(V)
    isPal#(V) -> activate#(V) -> activate#(n__u()) -> u#()
    isPal#(V) -> activate#(V) -> activate#(n__o()) -> o#()
    isPal#(V) -> activate#(V) -> activate#(n__i()) -> i#()
    isPal#(V) -> activate#(V) -> activate#(n__e()) -> e#()
    isPal#(V) -> activate#(V) -> activate#(n__a()) -> a#()
    isPal#(V) -> activate#(V) -> activate#(n__isPal(X)) -> isPal#(X)
    isPal#(V) -> activate#(V) -> activate#(n__isNeList(X)) -> isNeList#(X)
    isPal#(V) -> activate#(V) -> activate#(n__isList(X)) -> isList#(X)
    isPal#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isPal#(V) -> activate#(V) -> activate#(n____(X1,X2)) -> activate#(X1)
    isPal#(V) -> activate#(V) -> activate#(n____(X1,X2)) -> activate#(X2)
    isPal#(V) -> activate#(V) ->
    activate#(n__nil()) -> nil#()
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__u()) -> u#()
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__o()) -> o#()
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__i()) -> i#()
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__e()) -> e#()
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__a()) -> a#()
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__isPal(X)) -> isPal#(X)
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__isList(X)) -> isList#(X)
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isNePal#(n____(I,n____(P,I))) -> activate#(P) ->
    activate#(n__nil()) -> nil#()
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__u()) -> u#()
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__o()) -> o#()
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__i()) -> i#()
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__e()) -> e#()
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__a()) -> a#()
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__isPal(X)) -> isPal#(X)
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__isList(X)) -> isList#(X)
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isNePal#(n____(I,n____(P,I))) -> activate#(I) ->
    activate#(n__nil()) -> nil#()
    isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P))) ->
    and#(tt(),X) -> activate#(X)
    isNePal#(V) -> activate#(V) -> activate#(n__u()) -> u#()
    isNePal#(V) -> activate#(V) -> activate#(n__o()) -> o#()
    isNePal#(V) -> activate#(V) -> activate#(n__i()) -> i#()
    isNePal#(V) -> activate#(V) -> activate#(n__e()) -> e#()
    isNePal#(V) -> activate#(V) -> activate#(n__a()) -> a#()
    isNePal#(V) -> activate#(V) -> activate#(n__isPal(X)) -> isPal#(X)
    isNePal#(V) -> activate#(V) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isNePal#(V) -> activate#(V) -> activate#(n__isList(X)) -> isList#(X)
    isNePal#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isNePal#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isNePal#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isNePal#(V) -> activate#(V) ->
    activate#(n__nil()) -> nil#()
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(n____(V1,V2)) -> isList#(activate(V1))
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(n____(V1,V2)) -> activate#(V1)
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(n____(V1,V2)) -> activate#(V2)
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(V) -> isQid#(activate(V))
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1)) ->
    isNeList#(V) -> activate#(V)
    isNeList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
    isNeList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> isList#(activate(V1))
    isNeList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> activate#(V1)
    isNeList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> activate#(V2)
    isNeList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(V) -> isNeList#(activate(V))
    isNeList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(V) -> activate#(V)
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__u()) -> u#()
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__o()) -> o#()
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__i()) -> i#()
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__e()) -> e#()
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__a()) -> a#()
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__isPal(X)) -> isPal#(X)
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__isList(X)) -> isList#(X)
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isNeList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__nil()) -> nil#()
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__u()) -> u#()
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__o()) -> o#()
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__i()) -> i#()
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__e()) -> e#()
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__a()) -> a#()
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__isPal(X)) -> isPal#(X)
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__isList(X)) -> isList#(X)
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isNeList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__nil()) -> nil#()
    isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2))) ->
    and#(tt(),X) -> activate#(X)
    isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2))) ->
    and#(tt(),X) -> activate#(X)
    isNeList#(V) -> activate#(V) -> activate#(n__u()) -> u#()
    isNeList#(V) -> activate#(V) -> activate#(n__o()) -> o#()
    isNeList#(V) -> activate#(V) -> activate#(n__i()) -> i#()
    isNeList#(V) -> activate#(V) -> activate#(n__e()) -> e#()
    isNeList#(V) -> activate#(V) -> activate#(n__a()) -> a#()
    isNeList#(V) -> activate#(V) -> activate#(n__isPal(X)) -> isPal#(X)
    isNeList#(V) -> activate#(V) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isNeList#(V) -> activate#(V) ->
    activate#(n__isList(X)) -> isList#(X)
    isNeList#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isNeList#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isNeList#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isNeList#(V) -> activate#(V) ->
    activate#(n__nil()) -> nil#()
    isList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
    isList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> isList#(activate(V1))
    isList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> activate#(V1)
    isList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(n____(V1,V2)) -> activate#(V2)
    isList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(V) -> isNeList#(activate(V))
    isList#(n____(V1,V2)) -> isList#(activate(V1)) ->
    isList#(V) -> activate#(V)
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__u()) -> u#()
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__o()) -> o#()
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__i()) -> i#()
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__e()) -> e#()
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__a()) -> a#()
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__isPal(X)) -> isPal#(X)
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__isList(X)) -> isList#(X)
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isList#(n____(V1,V2)) -> activate#(V2) ->
    activate#(n__nil()) -> nil#()
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__u()) -> u#()
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__o()) -> o#()
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__i()) -> i#()
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__e()) -> e#()
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__a()) -> a#()
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__isPal(X)) -> isPal#(X)
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__isList(X)) -> isList#(X)
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isList#(n____(V1,V2)) -> activate#(V1) ->
    activate#(n__nil()) -> nil#()
    isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2))) ->
    and#(tt(),X) -> activate#(X)
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(n____(V1,V2)) -> isList#(activate(V1))
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(n____(V1,V2)) -> activate#(V1)
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(n____(V1,V2)) -> activate#(V2)
    isList#(V) -> isNeList#(activate(V)) ->
    isNeList#(V) -> isQid#(activate(V))
    isList#(V) -> isNeList#(activate(V)) -> isNeList#(V) -> activate#(V)
    isList#(V) -> activate#(V) -> activate#(n__u()) -> u#()
    isList#(V) -> activate#(V) -> activate#(n__o()) -> o#()
    isList#(V) -> activate#(V) -> activate#(n__i()) -> i#()
    isList#(V) -> activate#(V) -> activate#(n__e()) -> e#()
    isList#(V) -> activate#(V) -> activate#(n__a()) -> a#()
    isList#(V) -> activate#(V) -> activate#(n__isPal(X)) -> isPal#(X)
    isList#(V) -> activate#(V) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    isList#(V) -> activate#(V) -> activate#(n__isList(X)) -> isList#(X)
    isList#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    isList#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    isList#(V) -> activate#(V) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    isList#(V) -> activate#(V) -> activate#(n__nil()) -> nil#()
    activate#(n__isPal(X)) -> isPal#(X) ->
    isPal#(V) -> isNePal#(activate(V))
    activate#(n__isPal(X)) -> isPal#(X) ->
    isPal#(V) -> activate#(V)
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(n____(V1,V2)) -> isList#(activate(V1))
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(n____(V1,V2)) -> activate#(V1)
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(n____(V1,V2)) -> activate#(V2)
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(V) -> isQid#(activate(V))
    activate#(n__isNeList(X)) -> isNeList#(X) ->
    isNeList#(V) -> activate#(V)
    activate#(n__isList(X)) -> isList#(X) ->
    isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
    activate#(n__isList(X)) -> isList#(X) ->
    isList#(n____(V1,V2)) -> isList#(activate(V1))
    activate#(n__isList(X)) -> isList#(X) ->
    isList#(n____(V1,V2)) -> activate#(V1)
    activate#(n__isList(X)) -> isList#(X) ->
    isList#(n____(V1,V2)) -> activate#(V2)
    activate#(n__isList(X)) -> isList#(X) ->
    isList#(V) -> isNeList#(activate(V))
    activate#(n__isList(X)) -> isList#(X) ->
    isList#(V) -> activate#(V)
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__u()) -> u#()
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__o()) -> o#()
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__i()) -> i#()
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__e()) -> e#()
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__a()) -> a#()
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__isPal(X)) -> isPal#(X)
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__isList(X)) -> isList#(X)
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    activate#(n____(X1,X2)) -> activate#(X2) ->
    activate#(n__nil()) -> nil#()
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__u()) -> u#()
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__o()) -> o#()
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__i()) -> i#()
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__e()) -> e#()
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__a()) -> a#()
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__isPal(X)) -> isPal#(X)
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__isList(X)) -> isList#(X)
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    activate#(n____(X1,X2)) -> activate#(X1) ->
    activate#(n__nil()) -> nil#()
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2)) ->
    __#(__(X,Y),Z) -> __#(X,__(Y,Z))
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2)) ->
    __#(__(X,Y),Z) -> __#(Y,Z)
    and#(tt(),X) -> activate#(X) -> activate#(n__u()) -> u#()
    and#(tt(),X) -> activate#(X) -> activate#(n__o()) -> o#()
    and#(tt(),X) -> activate#(X) -> activate#(n__i()) -> i#()
    and#(tt(),X) -> activate#(X) -> activate#(n__e()) -> e#()
    and#(tt(),X) -> activate#(X) -> activate#(n__a()) -> a#()
    and#(tt(),X) -> activate#(X) -> activate#(n__isPal(X)) -> isPal#(X)
    and#(tt(),X) -> activate#(X) ->
    activate#(n__isNeList(X)) -> isNeList#(X)
    and#(tt(),X) -> activate#(X) ->
    activate#(n__isList(X)) -> isList#(X)
    and#(tt(),X) -> activate#(X) ->
    activate#(n____(X1,X2)) -> __#(activate(X1),activate(X2))
    and#(tt(),X) -> activate#(X) ->
    activate#(n____(X1,X2)) -> activate#(X1)
    and#(tt(),X) -> activate#(X) ->
    activate#(n____(X1,X2)) -> activate#(X2)
    and#(tt(),X) -> activate#(X) -> activate#(n__nil()) -> nil#()
    __#(__(X,Y),Z) -> __#(Y,Z) -> __#(__(X,Y),Z) -> __#(X,__(Y,Z))
    __#(__(X,Y),Z) -> __#(Y,Z) -> __#(__(X,Y),Z) -> __#(Y,Z)
    __#(__(X,Y),Z) -> __#(X,__(Y,Z)) ->
    __#(__(X,Y),Z) -> __#(X,__(Y,Z))
    __#(__(X,Y),Z) -> __#(X,__(Y,Z)) -> __#(__(X,Y),Z) -> __#(Y,Z)
   SCC Processor:
    #sccs: 2
    #rules: 27
    #arcs: 216/1369
    DPs:
     isPal#(V) -> isNePal#(activate(V))
     isNePal#(V) -> activate#(V)
     activate#(n____(X1,X2)) -> activate#(X2)
     activate#(n____(X1,X2)) -> activate#(X1)
     activate#(n__isList(X)) -> isList#(X)
     isList#(V) -> activate#(V)
     activate#(n__isNeList(X)) -> isNeList#(X)
     isNeList#(V) -> activate#(V)
     activate#(n__isPal(X)) -> isPal#(X)
     isPal#(V) -> activate#(V)
     isNeList#(n____(V1,V2)) -> activate#(V2)
     isNeList#(n____(V1,V2)) -> activate#(V1)
     isNeList#(n____(V1,V2)) -> isList#(activate(V1))
     isList#(V) -> isNeList#(activate(V))
     isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
     and#(tt(),X) -> activate#(X)
     isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
     isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
     isList#(n____(V1,V2)) -> activate#(V2)
     isList#(n____(V1,V2)) -> activate#(V1)
     isList#(n____(V1,V2)) -> isList#(activate(V1))
     isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
     isNePal#(n____(I,n____(P,I))) -> activate#(P)
     isNePal#(n____(I,n____(P,I))) -> activate#(I)
     isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P)))
    TRS:
     __(__(X,Y),Z) -> __(X,__(Y,Z))
     __(X,nil()) -> X
     __(nil(),X) -> X
     and(tt(),X) -> activate(X)
     isList(V) -> isNeList(activate(V))
     isList(n__nil()) -> tt()
     isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
     isNeList(V) -> isQid(activate(V))
     isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
     isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
     isNePal(V) -> isQid(activate(V))
     isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
     isPal(V) -> isNePal(activate(V))
     isPal(n__nil()) -> tt()
     isQid(n__a()) -> tt()
     isQid(n__e()) -> tt()
     isQid(n__i()) -> tt()
     isQid(n__o()) -> tt()
     isQid(n__u()) -> tt()
     nil() -> n__nil()
     __(X1,X2) -> n____(X1,X2)
     isList(X) -> n__isList(X)
     isNeList(X) -> n__isNeList(X)
     isPal(X) -> n__isPal(X)
     a() -> n__a()
     e() -> n__e()
     i() -> n__i()
     o() -> n__o()
     u() -> n__u()
     activate(n__nil()) -> nil()
     activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
     activate(n__isList(X)) -> isList(X)
     activate(n__isNeList(X)) -> isNeList(X)
     activate(n__isPal(X)) -> isPal(X)
     activate(n__a()) -> a()
     activate(n__e()) -> e()
     activate(n__i()) -> i()
     activate(n__o()) -> o()
     activate(n__u()) -> u()
     activate(X) -> X
    Arctic Interpretation Processor:
     dimension: 1
     interpretation:
      [isPal#](x0) = 6x0 + 1,
      
      [isNePal#](x0) = 6x0 + 0,
      
      [isNeList#](x0) = 6x0 + 0,
      
      [isList#](x0) = 6x0 + 0,
      
      [activate#](x0) = 1x0 + 0,
      
      [and#](x0, x1) = 1x0 + 1x1 + 0,
      
      [u] = 0,
      
      [o] = 0,
      
      [i] = 0,
      
      [e] = 1,
      
      [a] = 0,
      
      [n__u] = 0,
      
      [n__o] = 0,
      
      [n__i] = 0,
      
      [n__e] = 1,
      
      [n__a] = 0,
      
      [isPal](x0) = 5x0 + 0,
      
      [n__isPal](x0) = 5x0 + 0,
      
      [isNePal](x0) = 5x0 + 0,
      
      [n__isNeList](x0) = 5x0,
      
      [isQid](x0) = x0,
      
      [n__isList](x0) = 5x0,
      
      [n____](x0, x1) = x0 + x1 + 1,
      
      [n__nil] = 2,
      
      [isNeList](x0) = 5x0,
      
      [isList](x0) = 5x0,
      
      [activate](x0) = x0,
      
      [and](x0, x1) = x0 + x1,
      
      [tt] = 0,
      
      [nil] = 2,
      
      [__](x0, x1) = x0 + x1 + 1
     orientation:
      isPal#(V) = 6V + 1 >= 6V + 0 = isNePal#(activate(V))
      
      isNePal#(V) = 6V + 0 >= 1V + 0 = activate#(V)
      
      activate#(n____(X1,X2)) = 1X1 + 1X2 + 2 >= 1X2 + 0 = activate#(X2)
      
      activate#(n____(X1,X2)) = 1X1 + 1X2 + 2 >= 1X1 + 0 = activate#(X1)
      
      activate#(n__isList(X)) = 6X + 0 >= 6X + 0 = isList#(X)
      
      isList#(V) = 6V + 0 >= 1V + 0 = activate#(V)
      
      activate#(n__isNeList(X)) = 6X + 0 >= 6X + 0 = isNeList#(X)
      
      isNeList#(V) = 6V + 0 >= 1V + 0 = activate#(V)
      
      activate#(n__isPal(X)) = 6X + 1 >= 6X + 1 = isPal#(X)
      
      isPal#(V) = 6V + 1 >= 1V + 0 = activate#(V)
      
      isNeList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 1V2 + 0 = activate#(V2)
      
      isNeList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 1V1 + 0 = activate#(V1)
      
      isNeList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 6V1 + 0 = isList#(activate(V1))
      
      isList#(V) = 6V + 0 >= 6V + 0 = isNeList#(activate(V))
      
      isNeList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 6V1 + 6V2 + 0 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
      
      and#(tt(),X) = 1X + 1 >= 1X + 0 = activate#(X)
      
      isNeList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 6V1 + 0 = isNeList#(activate(V1))
      
      isNeList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 6V1 + 6V2 + 0 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
      
      isList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 1V2 + 0 = activate#(V2)
      
      isList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 1V1 + 0 = activate#(V1)
      
      isList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 6V1 + 0 = isList#(activate(V1))
      
      isList#(n____(V1,V2)) = 6V1 + 6V2 + 7 >= 6V1 + 6V2 + 0 = and#(isList(activate(V1)),n__isList(activate(V2)))
      
      isNePal#(n____(I,n____(P,I))) = 6I + 6P + 7 >= 1P + 0 = activate#(P)
      
      isNePal#(n____(I,n____(P,I))) = 6I + 6P + 7 >= 1I + 0 = activate#(I)
      
      isNePal#(n____(I,n____(P,I))) = 6I + 6P + 7 >= 1I + 6P + 1 = and#(isQid(activate(I)),n__isPal(activate(P)))
      
      __(__(X,Y),Z) = X + Y + Z + 1 >= X + Y + Z + 1 = __(X,__(Y,Z))
      
      __(X,nil()) = X + 2 >= X = X
      
      __(nil(),X) = X + 2 >= X = X
      
      and(tt(),X) = X + 0 >= X = activate(X)
      
      isList(V) = 5V >= 5V = isNeList(activate(V))
      
      isList(n__nil()) = 7 >= 0 = tt()
      
      isList(n____(V1,V2)) = 5V1 + 5V2 + 6 >= 5V1 + 5V2 = and(isList(activate(V1)),n__isList(activate(V2)))
      
      isNeList(V) = 5V >= V = isQid(activate(V))
      
      isNeList(n____(V1,V2)) = 5V1 + 5V2 + 6 >= 5V1 + 5V2 = and(isList(activate(V1)),n__isNeList(activate(V2)))
      
      isNeList(n____(V1,V2)) = 5V1 + 5V2 + 6 >= 5V1 + 5V2 = and(isNeList(activate(V1)),n__isList(activate(V2)))
      
      isNePal(V) = 5V + 0 >= V = isQid(activate(V))
      
      isNePal(n____(I,n____(P,I))) = 5I + 5P + 6 >= I + 5P + 0 = and(isQid(activate(I)),n__isPal(activate(P)))
      
      isPal(V) = 5V + 0 >= 5V + 0 = isNePal(activate(V))
      
      isPal(n__nil()) = 7 >= 0 = tt()
      
      isQid(n__a()) = 0 >= 0 = tt()
      
      isQid(n__e()) = 1 >= 0 = tt()
      
      isQid(n__i()) = 0 >= 0 = tt()
      
      isQid(n__o()) = 0 >= 0 = tt()
      
      isQid(n__u()) = 0 >= 0 = tt()
      
      nil() = 2 >= 2 = n__nil()
      
      __(X1,X2) = X1 + X2 + 1 >= X1 + X2 + 1 = n____(X1,X2)
      
      isList(X) = 5X >= 5X = n__isList(X)
      
      isNeList(X) = 5X >= 5X = n__isNeList(X)
      
      isPal(X) = 5X + 0 >= 5X + 0 = n__isPal(X)
      
      a() = 0 >= 0 = n__a()
      
      e() = 1 >= 1 = n__e()
      
      i() = 0 >= 0 = n__i()
      
      o() = 0 >= 0 = n__o()
      
      u() = 0 >= 0 = n__u()
      
      activate(n__nil()) = 2 >= 2 = nil()
      
      activate(n____(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = __(activate(X1),activate(X2))
      
      activate(n__isList(X)) = 5X >= 5X = isList(X)
      
      activate(n__isNeList(X)) = 5X >= 5X = isNeList(X)
      
      activate(n__isPal(X)) = 5X + 0 >= 5X + 0 = isPal(X)
      
      activate(n__a()) = 0 >= 0 = a()
      
      activate(n__e()) = 1 >= 1 = e()
      
      activate(n__i()) = 0 >= 0 = i()
      
      activate(n__o()) = 0 >= 0 = o()
      
      activate(n__u()) = 0 >= 0 = u()
      
      activate(X) = X >= X = X
     problem:
      DPs:
       isPal#(V) -> isNePal#(activate(V))
       isNePal#(V) -> activate#(V)
       activate#(n____(X1,X2)) -> activate#(X2)
       activate#(n____(X1,X2)) -> activate#(X1)
       activate#(n__isList(X)) -> isList#(X)
       isList#(V) -> activate#(V)
       activate#(n__isNeList(X)) -> isNeList#(X)
       isNeList#(V) -> activate#(V)
       activate#(n__isPal(X)) -> isPal#(X)
       isNeList#(n____(V1,V2)) -> isList#(activate(V1))
       isList#(V) -> isNeList#(activate(V))
       isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
       and#(tt(),X) -> activate#(X)
       isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
       isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
       isList#(n____(V1,V2)) -> isList#(activate(V1))
       isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
       isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P)))
      TRS:
       __(__(X,Y),Z) -> __(X,__(Y,Z))
       __(X,nil()) -> X
       __(nil(),X) -> X
       and(tt(),X) -> activate(X)
       isList(V) -> isNeList(activate(V))
       isList(n__nil()) -> tt()
       isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
       isNeList(V) -> isQid(activate(V))
       isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
       isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
       isNePal(V) -> isQid(activate(V))
       isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
       isPal(V) -> isNePal(activate(V))
       isPal(n__nil()) -> tt()
       isQid(n__a()) -> tt()
       isQid(n__e()) -> tt()
       isQid(n__i()) -> tt()
       isQid(n__o()) -> tt()
       isQid(n__u()) -> tt()
       nil() -> n__nil()
       __(X1,X2) -> n____(X1,X2)
       isList(X) -> n__isList(X)
       isNeList(X) -> n__isNeList(X)
       isPal(X) -> n__isPal(X)
       a() -> n__a()
       e() -> n__e()
       i() -> n__i()
       o() -> n__o()
       u() -> n__u()
       activate(n__nil()) -> nil()
       activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
       activate(n__isList(X)) -> isList(X)
       activate(n__isNeList(X)) -> isNeList(X)
       activate(n__isPal(X)) -> isPal(X)
       activate(n__a()) -> a()
       activate(n__e()) -> e()
       activate(n__i()) -> i()
       activate(n__o()) -> o()
       activate(n__u()) -> u()
       activate(X) -> X
     Arctic Interpretation Processor:
      dimension: 1
      interpretation:
       [isPal#](x0) = 1x0,
       
       [isNePal#](x0) = 1x0,
       
       [isNeList#](x0) = x0,
       
       [isList#](x0) = x0,
       
       [activate#](x0) = x0,
       
       [and#](x0, x1) = x1 + 0,
       
       [u] = 4,
       
       [o] = 0,
       
       [i] = 1,
       
       [e] = 4,
       
       [a] = 2,
       
       [n__u] = 4,
       
       [n__o] = 0,
       
       [n__i] = 1,
       
       [n__e] = 4,
       
       [n__a] = 2,
       
       [isPal](x0) = 1x0 + 0,
       
       [n__isPal](x0) = 1x0 + 0,
       
       [isNePal](x0) = 1x0,
       
       [n__isNeList](x0) = x0,
       
       [isQid](x0) = x0,
       
       [n__isList](x0) = x0 + 2,
       
       [n____](x0, x1) = x0 + x1 + 2,
       
       [n__nil] = 0,
       
       [isNeList](x0) = x0,
       
       [isList](x0) = x0 + 2,
       
       [activate](x0) = x0,
       
       [and](x0, x1) = x1,
       
       [tt] = 0,
       
       [nil] = 0,
       
       [__](x0, x1) = x0 + x1 + 2
      orientation:
       isPal#(V) = 1V >= 1V = isNePal#(activate(V))
       
       isNePal#(V) = 1V >= V = activate#(V)
       
       activate#(n____(X1,X2)) = X1 + X2 + 2 >= X2 = activate#(X2)
       
       activate#(n____(X1,X2)) = X1 + X2 + 2 >= X1 = activate#(X1)
       
       activate#(n__isList(X)) = X + 2 >= X = isList#(X)
       
       isList#(V) = V >= V = activate#(V)
       
       activate#(n__isNeList(X)) = X >= X = isNeList#(X)
       
       isNeList#(V) = V >= V = activate#(V)
       
       activate#(n__isPal(X)) = 1X + 0 >= 1X = isPal#(X)
       
       isNeList#(n____(V1,V2)) = V1 + V2 + 2 >= V1 = isList#(activate(V1))
       
       isList#(V) = V >= V = isNeList#(activate(V))
       
       isNeList#(n____(V1,V2)) = V1 + V2 + 2 >= V2 + 0 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
       
       and#(tt(),X) = X + 0 >= X = activate#(X)
       
       isNeList#(n____(V1,V2)) = V1 + V2 + 2 >= V1 = isNeList#(activate(V1))
       
       isNeList#(n____(V1,V2)) = V1 + V2 + 2 >= V2 + 2 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
       
       isList#(n____(V1,V2)) = V1 + V2 + 2 >= V1 = isList#(activate(V1))
       
       isList#(n____(V1,V2)) = V1 + V2 + 2 >= V2 + 2 = and#(isList(activate(V1)),n__isList(activate(V2)))
       
       isNePal#(n____(I,n____(P,I))) = 1I + 1P + 3 >= 1P + 0 = and#(isQid(activate(I)),n__isPal(activate(P)))
       
       __(__(X,Y),Z) = X + Y + Z + 2 >= X + Y + Z + 2 = __(X,__(Y,Z))
       
       __(X,nil()) = X + 2 >= X = X
       
       __(nil(),X) = X + 2 >= X = X
       
       and(tt(),X) = X >= X = activate(X)
       
       isList(V) = V + 2 >= V = isNeList(activate(V))
       
       isList(n__nil()) = 2 >= 0 = tt()
       
       isList(n____(V1,V2)) = V1 + V2 + 2 >= V2 + 2 = and(isList(activate(V1)),n__isList(activate(V2)))
       
       isNeList(V) = V >= V = isQid(activate(V))
       
       isNeList(n____(V1,V2)) = V1 + V2 + 2 >= V2 = and(isList(activate(V1)),n__isNeList(activate(V2)))
       
       isNeList(n____(V1,V2)) = V1 + V2 + 2 >= V2 + 2 = and(isNeList(activate(V1)),n__isList(activate(V2)))
       
       isNePal(V) = 1V >= V = isQid(activate(V))
       
       isNePal(n____(I,n____(P,I))) = 1I + 1P + 3 >= 1P + 0 = and(isQid(activate(I)),n__isPal(activate(P)))
       
       isPal(V) = 1V + 0 >= 1V = isNePal(activate(V))
       
       isPal(n__nil()) = 1 >= 0 = tt()
       
       isQid(n__a()) = 2 >= 0 = tt()
       
       isQid(n__e()) = 4 >= 0 = tt()
       
       isQid(n__i()) = 1 >= 0 = tt()
       
       isQid(n__o()) = 0 >= 0 = tt()
       
       isQid(n__u()) = 4 >= 0 = tt()
       
       nil() = 0 >= 0 = n__nil()
       
       __(X1,X2) = X1 + X2 + 2 >= X1 + X2 + 2 = n____(X1,X2)
       
       isList(X) = X + 2 >= X + 2 = n__isList(X)
       
       isNeList(X) = X >= X = n__isNeList(X)
       
       isPal(X) = 1X + 0 >= 1X + 0 = n__isPal(X)
       
       a() = 2 >= 2 = n__a()
       
       e() = 4 >= 4 = n__e()
       
       i() = 1 >= 1 = n__i()
       
       o() = 0 >= 0 = n__o()
       
       u() = 4 >= 4 = n__u()
       
       activate(n__nil()) = 0 >= 0 = nil()
       
       activate(n____(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = __(activate(X1),activate(X2))
       
       activate(n__isList(X)) = X + 2 >= X + 2 = isList(X)
       
       activate(n__isNeList(X)) = X >= X = isNeList(X)
       
       activate(n__isPal(X)) = 1X + 0 >= 1X + 0 = isPal(X)
       
       activate(n__a()) = 2 >= 2 = a()
       
       activate(n__e()) = 4 >= 4 = e()
       
       activate(n__i()) = 1 >= 1 = i()
       
       activate(n__o()) = 0 >= 0 = o()
       
       activate(n__u()) = 4 >= 4 = u()
       
       activate(X) = X >= X = X
      problem:
       DPs:
        isPal#(V) -> isNePal#(activate(V))
        activate#(n____(X1,X2)) -> activate#(X2)
        activate#(n____(X1,X2)) -> activate#(X1)
        activate#(n__isList(X)) -> isList#(X)
        isList#(V) -> activate#(V)
        activate#(n__isNeList(X)) -> isNeList#(X)
        isNeList#(V) -> activate#(V)
        activate#(n__isPal(X)) -> isPal#(X)
        isNeList#(n____(V1,V2)) -> isList#(activate(V1))
        isList#(V) -> isNeList#(activate(V))
        isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
        and#(tt(),X) -> activate#(X)
        isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
        isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
        isList#(n____(V1,V2)) -> isList#(activate(V1))
        isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
        isNePal#(n____(I,n____(P,I))) -> and#(isQid(activate(I)),n__isPal(activate(P)))
       TRS:
        __(__(X,Y),Z) -> __(X,__(Y,Z))
        __(X,nil()) -> X
        __(nil(),X) -> X
        and(tt(),X) -> activate(X)
        isList(V) -> isNeList(activate(V))
        isList(n__nil()) -> tt()
        isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
        isNeList(V) -> isQid(activate(V))
        isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
        isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
        isNePal(V) -> isQid(activate(V))
        isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
        isPal(V) -> isNePal(activate(V))
        isPal(n__nil()) -> tt()
        isQid(n__a()) -> tt()
        isQid(n__e()) -> tt()
        isQid(n__i()) -> tt()
        isQid(n__o()) -> tt()
        isQid(n__u()) -> tt()
        nil() -> n__nil()
        __(X1,X2) -> n____(X1,X2)
        isList(X) -> n__isList(X)
        isNeList(X) -> n__isNeList(X)
        isPal(X) -> n__isPal(X)
        a() -> n__a()
        e() -> n__e()
        i() -> n__i()
        o() -> n__o()
        u() -> n__u()
        activate(n__nil()) -> nil()
        activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
        activate(n__isList(X)) -> isList(X)
        activate(n__isNeList(X)) -> isNeList(X)
        activate(n__isPal(X)) -> isPal(X)
        activate(n__a()) -> a()
        activate(n__e()) -> e()
        activate(n__i()) -> i()
        activate(n__o()) -> o()
        activate(n__u()) -> u()
        activate(X) -> X
      Arctic Interpretation Processor:
       dimension: 1
       interpretation:
        [isPal#](x0) = 4x0 + 0,
        
        [isNePal#](x0) = 4x0 + 0,
        
        [isNeList#](x0) = 6x0 + 0,
        
        [isList#](x0) = 6x0 + 0,
        
        [activate#](x0) = x0 + 0,
        
        [and#](x0, x1) = x0 + x1,
        
        [u] = 0,
        
        [o] = 0,
        
        [i] = 1,
        
        [e] = 0,
        
        [a] = 3,
        
        [n__u] = 0,
        
        [n__o] = 0,
        
        [n__i] = 1,
        
        [n__e] = 0,
        
        [n__a] = 3,
        
        [isPal](x0) = 4x0,
        
        [n__isPal](x0) = 4x0,
        
        [isNePal](x0) = 3x0,
        
        [n__isNeList](x0) = 6x0,
        
        [isQid](x0) = 3x0,
        
        [n__isList](x0) = 6x0 + 0,
        
        [n____](x0, x1) = 1x0 + x1 + 0,
        
        [n__nil] = 0,
        
        [isNeList](x0) = 6x0,
        
        [isList](x0) = 6x0 + 0,
        
        [activate](x0) = x0,
        
        [and](x0, x1) = 1x0 + x1,
        
        [tt] = 2,
        
        [nil] = 0,
        
        [__](x0, x1) = 1x0 + x1 + 0
       orientation:
        isPal#(V) = 4V + 0 >= 4V + 0 = isNePal#(activate(V))
        
        activate#(n____(X1,X2)) = 1X1 + X2 + 0 >= X2 + 0 = activate#(X2)
        
        activate#(n____(X1,X2)) = 1X1 + X2 + 0 >= X1 + 0 = activate#(X1)
        
        activate#(n__isList(X)) = 6X + 0 >= 6X + 0 = isList#(X)
        
        isList#(V) = 6V + 0 >= V + 0 = activate#(V)
        
        activate#(n__isNeList(X)) = 6X + 0 >= 6X + 0 = isNeList#(X)
        
        isNeList#(V) = 6V + 0 >= V + 0 = activate#(V)
        
        activate#(n__isPal(X)) = 4X + 0 >= 4X + 0 = isPal#(X)
        
        isNeList#(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 6V1 + 0 = isList#(activate(V1))
        
        isList#(V) = 6V + 0 >= 6V + 0 = isNeList#(activate(V))
        
        isNeList#(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 6V1 + 6V2 + 0 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
        
        and#(tt(),X) = X + 2 >= X + 0 = activate#(X)
        
        isNeList#(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 6V1 + 0 = isNeList#(activate(V1))
        
        isNeList#(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 6V1 + 6V2 + 0 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
        
        isList#(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 6V1 + 0 = isList#(activate(V1))
        
        isList#(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 6V1 + 6V2 + 0 = and#(isList(activate(V1)),n__isList(activate(V2)))
        
        isNePal#(n____(I,n____(P,I))) = 5I + 5P + 4 >= 3I + 4P = and#(isQid(activate(I)),n__isPal(activate(P)))
        
        __(__(X,Y),Z) = 2X + 1Y + Z + 1 >= 1X + 1Y + Z + 0 = __(X,__(Y,Z))
        
        __(X,nil()) = 1X + 0 >= X = X
        
        __(nil(),X) = X + 1 >= X = X
        
        and(tt(),X) = X + 3 >= X = activate(X)
        
        isList(V) = 6V + 0 >= 6V = isNeList(activate(V))
        
        isList(n__nil()) = 6 >= 2 = tt()
        
        isList(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 7V1 + 6V2 + 1 = and(isList(activate(V1)),n__isList(activate(V2)))
        
        isNeList(V) = 6V >= 3V = isQid(activate(V))
        
        isNeList(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 7V1 + 6V2 + 1 = and(isList(activate(V1)),n__isNeList(activate(V2)))
        
        isNeList(n____(V1,V2)) = 7V1 + 6V2 + 6 >= 7V1 + 6V2 + 0 = and(isNeList(activate(V1)),n__isList(activate(V2)))
        
        isNePal(V) = 3V >= 3V = isQid(activate(V))
        
        isNePal(n____(I,n____(P,I))) = 4I + 4P + 3 >= 4I + 4P = and(isQid(activate(I)),n__isPal(activate(P)))
        
        isPal(V) = 4V >= 3V = isNePal(activate(V))
        
        isPal(n__nil()) = 4 >= 2 = tt()
        
        isQid(n__a()) = 6 >= 2 = tt()
        
        isQid(n__e()) = 3 >= 2 = tt()
        
        isQid(n__i()) = 4 >= 2 = tt()
        
        isQid(n__o()) = 3 >= 2 = tt()
        
        isQid(n__u()) = 3 >= 2 = tt()
        
        nil() = 0 >= 0 = n__nil()
        
        __(X1,X2) = 1X1 + X2 + 0 >= 1X1 + X2 + 0 = n____(X1,X2)
        
        isList(X) = 6X + 0 >= 6X + 0 = n__isList(X)
        
        isNeList(X) = 6X >= 6X = n__isNeList(X)
        
        isPal(X) = 4X >= 4X = n__isPal(X)
        
        a() = 3 >= 3 = n__a()
        
        e() = 0 >= 0 = n__e()
        
        i() = 1 >= 1 = n__i()
        
        o() = 0 >= 0 = n__o()
        
        u() = 0 >= 0 = n__u()
        
        activate(n__nil()) = 0 >= 0 = nil()
        
        activate(n____(X1,X2)) = 1X1 + X2 + 0 >= 1X1 + X2 + 0 = __(activate(X1),activate(X2))
        
        activate(n__isList(X)) = 6X + 0 >= 6X + 0 = isList(X)
        
        activate(n__isNeList(X)) = 6X >= 6X = isNeList(X)
        
        activate(n__isPal(X)) = 4X >= 4X = isPal(X)
        
        activate(n__a()) = 3 >= 3 = a()
        
        activate(n__e()) = 0 >= 0 = e()
        
        activate(n__i()) = 1 >= 1 = i()
        
        activate(n__o()) = 0 >= 0 = o()
        
        activate(n__u()) = 0 >= 0 = u()
        
        activate(X) = X >= X = X
       problem:
        DPs:
         isPal#(V) -> isNePal#(activate(V))
         activate#(n____(X1,X2)) -> activate#(X2)
         activate#(n____(X1,X2)) -> activate#(X1)
         activate#(n__isList(X)) -> isList#(X)
         isList#(V) -> activate#(V)
         activate#(n__isNeList(X)) -> isNeList#(X)
         isNeList#(V) -> activate#(V)
         activate#(n__isPal(X)) -> isPal#(X)
         isList#(V) -> isNeList#(activate(V))
         isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
         and#(tt(),X) -> activate#(X)
         isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
         isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
        TRS:
         __(__(X,Y),Z) -> __(X,__(Y,Z))
         __(X,nil()) -> X
         __(nil(),X) -> X
         and(tt(),X) -> activate(X)
         isList(V) -> isNeList(activate(V))
         isList(n__nil()) -> tt()
         isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
         isNeList(V) -> isQid(activate(V))
         isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
         isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
         isNePal(V) -> isQid(activate(V))
         isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
         isPal(V) -> isNePal(activate(V))
         isPal(n__nil()) -> tt()
         isQid(n__a()) -> tt()
         isQid(n__e()) -> tt()
         isQid(n__i()) -> tt()
         isQid(n__o()) -> tt()
         isQid(n__u()) -> tt()
         nil() -> n__nil()
         __(X1,X2) -> n____(X1,X2)
         isList(X) -> n__isList(X)
         isNeList(X) -> n__isNeList(X)
         isPal(X) -> n__isPal(X)
         a() -> n__a()
         e() -> n__e()
         i() -> n__i()
         o() -> n__o()
         u() -> n__u()
         activate(n__nil()) -> nil()
         activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
         activate(n__isList(X)) -> isList(X)
         activate(n__isNeList(X)) -> isNeList(X)
         activate(n__isPal(X)) -> isPal(X)
         activate(n__a()) -> a()
         activate(n__e()) -> e()
         activate(n__i()) -> i()
         activate(n__o()) -> o()
         activate(n__u()) -> u()
         activate(X) -> X
       SCC Processor:
        #sccs: 1
        #rules: 11
        #arcs: 114/169
        DPs:
         isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
         and#(tt(),X) -> activate#(X)
         activate#(n____(X1,X2)) -> activate#(X2)
         activate#(n____(X1,X2)) -> activate#(X1)
         activate#(n__isList(X)) -> isList#(X)
         isList#(V) -> activate#(V)
         activate#(n__isNeList(X)) -> isNeList#(X)
         isNeList#(V) -> activate#(V)
         isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
         isList#(V) -> isNeList#(activate(V))
         isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
        TRS:
         __(__(X,Y),Z) -> __(X,__(Y,Z))
         __(X,nil()) -> X
         __(nil(),X) -> X
         and(tt(),X) -> activate(X)
         isList(V) -> isNeList(activate(V))
         isList(n__nil()) -> tt()
         isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
         isNeList(V) -> isQid(activate(V))
         isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
         isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
         isNePal(V) -> isQid(activate(V))
         isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
         isPal(V) -> isNePal(activate(V))
         isPal(n__nil()) -> tt()
         isQid(n__a()) -> tt()
         isQid(n__e()) -> tt()
         isQid(n__i()) -> tt()
         isQid(n__o()) -> tt()
         isQid(n__u()) -> tt()
         nil() -> n__nil()
         __(X1,X2) -> n____(X1,X2)
         isList(X) -> n__isList(X)
         isNeList(X) -> n__isNeList(X)
         isPal(X) -> n__isPal(X)
         a() -> n__a()
         e() -> n__e()
         i() -> n__i()
         o() -> n__o()
         u() -> n__u()
         activate(n__nil()) -> nil()
         activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
         activate(n__isList(X)) -> isList(X)
         activate(n__isNeList(X)) -> isNeList(X)
         activate(n__isPal(X)) -> isPal(X)
         activate(n__a()) -> a()
         activate(n__e()) -> e()
         activate(n__i()) -> i()
         activate(n__o()) -> o()
         activate(n__u()) -> u()
         activate(X) -> X
        Arctic Interpretation Processor:
         dimension: 1
         interpretation:
          [isNeList#](x0) = x0 + 0,
          
          [isList#](x0) = x0 + 0,
          
          [activate#](x0) = x0,
          
          [and#](x0, x1) = x1 + 4,
          
          [u] = 1,
          
          [o] = 0,
          
          [i] = 0,
          
          [e] = 1,
          
          [a] = 0,
          
          [n__u] = 1,
          
          [n__o] = 0,
          
          [n__i] = 0,
          
          [n__e] = 1,
          
          [n__a] = 0,
          
          [isPal](x0) = x0 + 7,
          
          [n__isPal](x0) = x0 + 7,
          
          [isNePal](x0) = x0 + 7,
          
          [n__isNeList](x0) = x0 + 0,
          
          [isQid](x0) = x0,
          
          [n__isList](x0) = x0 + 0,
          
          [n____](x0, x1) = 1x0 + x1 + 4,
          
          [n__nil] = 0,
          
          [isNeList](x0) = x0 + 0,
          
          [isList](x0) = x0 + 0,
          
          [activate](x0) = x0,
          
          [and](x0, x1) = x0 + x1 + 1,
          
          [tt] = 0,
          
          [nil] = 0,
          
          [__](x0, x1) = 1x0 + x1 + 4
         orientation:
          isNeList#(n____(V1,V2)) = 1V1 + V2 + 4 >= V2 + 4 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
          
          and#(tt(),X) = X + 4 >= X = activate#(X)
          
          activate#(n____(X1,X2)) = 1X1 + X2 + 4 >= X2 = activate#(X2)
          
          activate#(n____(X1,X2)) = 1X1 + X2 + 4 >= X1 = activate#(X1)
          
          activate#(n__isList(X)) = X + 0 >= X + 0 = isList#(X)
          
          isList#(V) = V + 0 >= V = activate#(V)
          
          activate#(n__isNeList(X)) = X + 0 >= X + 0 = isNeList#(X)
          
          isNeList#(V) = V + 0 >= V = activate#(V)
          
          isNeList#(n____(V1,V2)) = 1V1 + V2 + 4 >= V2 + 4 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
          
          isList#(V) = V + 0 >= V + 0 = isNeList#(activate(V))
          
          isList#(n____(V1,V2)) = 1V1 + V2 + 4 >= V2 + 4 = and#(isList(activate(V1)),n__isList(activate(V2)))
          
          __(__(X,Y),Z) = 2X + 1Y + Z + 5 >= 1X + 1Y + Z + 4 = __(X,__(Y,Z))
          
          __(X,nil()) = 1X + 4 >= X = X
          
          __(nil(),X) = X + 4 >= X = X
          
          and(tt(),X) = X + 1 >= X = activate(X)
          
          isList(V) = V + 0 >= V + 0 = isNeList(activate(V))
          
          isList(n__nil()) = 0 >= 0 = tt()
          
          isList(n____(V1,V2)) = 1V1 + V2 + 4 >= V1 + V2 + 1 = and(isList(activate(V1)),n__isList(activate(V2)))
          
          isNeList(V) = V + 0 >= V = isQid(activate(V))
          
          isNeList(n____(V1,V2)) = 1V1 + V2 + 4 >= V1 + V2 + 1 = and(isList(activate(V1)),n__isNeList(activate(V2)))
          
          isNeList(n____(V1,V2)) = 1V1 + V2 + 4 >= V1 + V2 + 1 = and(isNeList(activate(V1)),n__isList(activate(V2)))
          
          isNePal(V) = V + 7 >= V = isQid(activate(V))
          
          isNePal(n____(I,n____(P,I))) = 1I + 1P + 7 >= I + P + 7 = and(isQid(activate(I)),n__isPal(activate(P)))
          
          isPal(V) = V + 7 >= V + 7 = isNePal(activate(V))
          
          isPal(n__nil()) = 7 >= 0 = tt()
          
          isQid(n__a()) = 0 >= 0 = tt()
          
          isQid(n__e()) = 1 >= 0 = tt()
          
          isQid(n__i()) = 0 >= 0 = tt()
          
          isQid(n__o()) = 0 >= 0 = tt()
          
          isQid(n__u()) = 1 >= 0 = tt()
          
          nil() = 0 >= 0 = n__nil()
          
          __(X1,X2) = 1X1 + X2 + 4 >= 1X1 + X2 + 4 = n____(X1,X2)
          
          isList(X) = X + 0 >= X + 0 = n__isList(X)
          
          isNeList(X) = X + 0 >= X + 0 = n__isNeList(X)
          
          isPal(X) = X + 7 >= X + 7 = n__isPal(X)
          
          a() = 0 >= 0 = n__a()
          
          e() = 1 >= 1 = n__e()
          
          i() = 0 >= 0 = n__i()
          
          o() = 0 >= 0 = n__o()
          
          u() = 1 >= 1 = n__u()
          
          activate(n__nil()) = 0 >= 0 = nil()
          
          activate(n____(X1,X2)) = 1X1 + X2 + 4 >= 1X1 + X2 + 4 = __(activate(X1),activate(X2))
          
          activate(n__isList(X)) = X + 0 >= X + 0 = isList(X)
          
          activate(n__isNeList(X)) = X + 0 >= X + 0 = isNeList(X)
          
          activate(n__isPal(X)) = X + 7 >= X + 7 = isPal(X)
          
          activate(n__a()) = 0 >= 0 = a()
          
          activate(n__e()) = 1 >= 1 = e()
          
          activate(n__i()) = 0 >= 0 = i()
          
          activate(n__o()) = 0 >= 0 = o()
          
          activate(n__u()) = 1 >= 1 = u()
          
          activate(X) = X >= X = X
         problem:
          DPs:
           isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
           and#(tt(),X) -> activate#(X)
           activate#(n____(X1,X2)) -> activate#(X2)
           activate#(n__isList(X)) -> isList#(X)
           isList#(V) -> activate#(V)
           activate#(n__isNeList(X)) -> isNeList#(X)
           isNeList#(V) -> activate#(V)
           isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
           isList#(V) -> isNeList#(activate(V))
           isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
          TRS:
           __(__(X,Y),Z) -> __(X,__(Y,Z))
           __(X,nil()) -> X
           __(nil(),X) -> X
           and(tt(),X) -> activate(X)
           isList(V) -> isNeList(activate(V))
           isList(n__nil()) -> tt()
           isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
           isNeList(V) -> isQid(activate(V))
           isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
           isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
           isNePal(V) -> isQid(activate(V))
           isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
           isPal(V) -> isNePal(activate(V))
           isPal(n__nil()) -> tt()
           isQid(n__a()) -> tt()
           isQid(n__e()) -> tt()
           isQid(n__i()) -> tt()
           isQid(n__o()) -> tt()
           isQid(n__u()) -> tt()
           nil() -> n__nil()
           __(X1,X2) -> n____(X1,X2)
           isList(X) -> n__isList(X)
           isNeList(X) -> n__isNeList(X)
           isPal(X) -> n__isPal(X)
           a() -> n__a()
           e() -> n__e()
           i() -> n__i()
           o() -> n__o()
           u() -> n__u()
           activate(n__nil()) -> nil()
           activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
           activate(n__isList(X)) -> isList(X)
           activate(n__isNeList(X)) -> isNeList(X)
           activate(n__isPal(X)) -> isPal(X)
           activate(n__a()) -> a()
           activate(n__e()) -> e()
           activate(n__i()) -> i()
           activate(n__o()) -> o()
           activate(n__u()) -> u()
           activate(X) -> X
         Arctic Interpretation Processor:
          dimension: 1
          interpretation:
           [isNeList#](x0) = 1x0,
           
           [isList#](x0) = 1x0,
           
           [activate#](x0) = x0,
           
           [and#](x0, x1) = x0 + x1 + 1,
           
           [u] = 6,
           
           [o] = 3,
           
           [i] = 0,
           
           [e] = 0,
           
           [a] = 7,
           
           [n__u] = 6,
           
           [n__o] = 3,
           
           [n__i] = 0,
           
           [n__e] = 0,
           
           [n__a] = 7,
           
           [isPal](x0) = x0 + 0,
           
           [n__isPal](x0) = x0 + 0,
           
           [isNePal](x0) = x0 + 0,
           
           [n__isNeList](x0) = 1x0 + 0,
           
           [isQid](x0) = 0,
           
           [n__isList](x0) = 1x0 + 0,
           
           [n____](x0, x1) = x0 + x1 + 0,
           
           [n__nil] = 1,
           
           [isNeList](x0) = 1x0 + 0,
           
           [isList](x0) = 1x0 + 0,
           
           [activate](x0) = x0,
           
           [and](x0, x1) = x1,
           
           [tt] = 0,
           
           [nil] = 1,
           
           [__](x0, x1) = x0 + x1 + 0
          orientation:
           isNeList#(n____(V1,V2)) = 1V1 + 1V2 + 1 >= 1V1 + 1V2 + 1 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
           
           and#(tt(),X) = X + 1 >= X = activate#(X)
           
           activate#(n____(X1,X2)) = X1 + X2 + 0 >= X2 = activate#(X2)
           
           activate#(n__isList(X)) = 1X + 0 >= 1X = isList#(X)
           
           isList#(V) = 1V >= V = activate#(V)
           
           activate#(n__isNeList(X)) = 1X + 0 >= 1X = isNeList#(X)
           
           isNeList#(V) = 1V >= V = activate#(V)
           
           isNeList#(n____(V1,V2)) = 1V1 + 1V2 + 1 >= 1V1 + 1V2 + 1 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
           
           isList#(V) = 1V >= 1V = isNeList#(activate(V))
           
           isList#(n____(V1,V2)) = 1V1 + 1V2 + 1 >= 1V1 + 1V2 + 1 = and#(isList(activate(V1)),n__isList(activate(V2)))
           
           __(__(X,Y),Z) = X + Y + Z + 0 >= X + Y + Z + 0 = __(X,__(Y,Z))
           
           __(X,nil()) = X + 1 >= X = X
           
           __(nil(),X) = X + 1 >= X = X
           
           and(tt(),X) = X >= X = activate(X)
           
           isList(V) = 1V + 0 >= 1V + 0 = isNeList(activate(V))
           
           isList(n__nil()) = 2 >= 0 = tt()
           
           isList(n____(V1,V2)) = 1V1 + 1V2 + 1 >= 1V2 + 0 = and(isList(activate(V1)),n__isList(activate(V2)))
           
           isNeList(V) = 1V + 0 >= 0 = isQid(activate(V))
           
           isNeList(n____(V1,V2)) = 1V1 + 1V2 + 1 >= 1V2 + 0 = and(isList(activate(V1)),n__isNeList(activate(V2)))
           
           isNeList(n____(V1,V2)) = 1V1 + 1V2 + 1 >= 1V2 + 0 = and(isNeList(activate(V1)),n__isList(activate(V2)))
           
           isNePal(V) = V + 0 >= 0 = isQid(activate(V))
           
           isNePal(n____(I,n____(P,I))) = I + P + 0 >= P + 0 = and(isQid(activate(I)),n__isPal(activate(P)))
           
           isPal(V) = V + 0 >= V + 0 = isNePal(activate(V))
           
           isPal(n__nil()) = 1 >= 0 = tt()
           
           isQid(n__a()) = 0 >= 0 = tt()
           
           isQid(n__e()) = 0 >= 0 = tt()
           
           isQid(n__i()) = 0 >= 0 = tt()
           
           isQid(n__o()) = 0 >= 0 = tt()
           
           isQid(n__u()) = 0 >= 0 = tt()
           
           nil() = 1 >= 1 = n__nil()
           
           __(X1,X2) = X1 + X2 + 0 >= X1 + X2 + 0 = n____(X1,X2)
           
           isList(X) = 1X + 0 >= 1X + 0 = n__isList(X)
           
           isNeList(X) = 1X + 0 >= 1X + 0 = n__isNeList(X)
           
           isPal(X) = X + 0 >= X + 0 = n__isPal(X)
           
           a() = 7 >= 7 = n__a()
           
           e() = 0 >= 0 = n__e()
           
           i() = 0 >= 0 = n__i()
           
           o() = 3 >= 3 = n__o()
           
           u() = 6 >= 6 = n__u()
           
           activate(n__nil()) = 1 >= 1 = nil()
           
           activate(n____(X1,X2)) = X1 + X2 + 0 >= X1 + X2 + 0 = __(activate(X1),activate(X2))
           
           activate(n__isList(X)) = 1X + 0 >= 1X + 0 = isList(X)
           
           activate(n__isNeList(X)) = 1X + 0 >= 1X + 0 = isNeList(X)
           
           activate(n__isPal(X)) = X + 0 >= X + 0 = isPal(X)
           
           activate(n__a()) = 7 >= 7 = a()
           
           activate(n__e()) = 0 >= 0 = e()
           
           activate(n__i()) = 0 >= 0 = i()
           
           activate(n__o()) = 3 >= 3 = o()
           
           activate(n__u()) = 6 >= 6 = u()
           
           activate(X) = X >= X = X
          problem:
           DPs:
            isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
            and#(tt(),X) -> activate#(X)
            activate#(n____(X1,X2)) -> activate#(X2)
            activate#(n__isList(X)) -> isList#(X)
            activate#(n__isNeList(X)) -> isNeList#(X)
            isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
            isList#(V) -> isNeList#(activate(V))
            isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
           TRS:
            __(__(X,Y),Z) -> __(X,__(Y,Z))
            __(X,nil()) -> X
            __(nil(),X) -> X
            and(tt(),X) -> activate(X)
            isList(V) -> isNeList(activate(V))
            isList(n__nil()) -> tt()
            isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
            isNeList(V) -> isQid(activate(V))
            isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
            isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
            isNePal(V) -> isQid(activate(V))
            isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
            isPal(V) -> isNePal(activate(V))
            isPal(n__nil()) -> tt()
            isQid(n__a()) -> tt()
            isQid(n__e()) -> tt()
            isQid(n__i()) -> tt()
            isQid(n__o()) -> tt()
            isQid(n__u()) -> tt()
            nil() -> n__nil()
            __(X1,X2) -> n____(X1,X2)
            isList(X) -> n__isList(X)
            isNeList(X) -> n__isNeList(X)
            isPal(X) -> n__isPal(X)
            a() -> n__a()
            e() -> n__e()
            i() -> n__i()
            o() -> n__o()
            u() -> n__u()
            activate(n__nil()) -> nil()
            activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
            activate(n__isList(X)) -> isList(X)
            activate(n__isNeList(X)) -> isNeList(X)
            activate(n__isPal(X)) -> isPal(X)
            activate(n__a()) -> a()
            activate(n__e()) -> e()
            activate(n__i()) -> i()
            activate(n__o()) -> o()
            activate(n__u()) -> u()
            activate(X) -> X
          Matrix Interpretation Processor: dim=1
           
           interpretation:
            [isNeList#](x0) = 1,
            
            [isList#](x0) = 1,
            
            [activate#](x0) = x0 + 1,
            
            [and#](x0, x1) = x1 + 1,
            
            [u] = 4,
            
            [o] = 0,
            
            [i] = 2,
            
            [e] = 1,
            
            [a] = 0,
            
            [n__u] = 4,
            
            [n__o] = 0,
            
            [n__i] = 2,
            
            [n__e] = 1,
            
            [n__a] = 0,
            
            [isPal](x0) = 0,
            
            [n__isPal](x0) = 0,
            
            [isNePal](x0) = 0,
            
            [n__isNeList](x0) = 0,
            
            [isQid](x0) = 0,
            
            [n__isList](x0) = 0,
            
            [n____](x0, x1) = 4x0 + x1 + 1,
            
            [n__nil] = 0,
            
            [isNeList](x0) = 0,
            
            [isList](x0) = 0,
            
            [activate](x0) = x0,
            
            [and](x0, x1) = x1,
            
            [tt] = 0,
            
            [nil] = 0,
            
            [__](x0, x1) = 4x0 + x1 + 1
           orientation:
            isNeList#(n____(V1,V2)) = 1 >= 1 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
            
            and#(tt(),X) = X + 1 >= X + 1 = activate#(X)
            
            activate#(n____(X1,X2)) = 4X1 + X2 + 2 >= X2 + 1 = activate#(X2)
            
            activate#(n__isList(X)) = 1 >= 1 = isList#(X)
            
            activate#(n__isNeList(X)) = 1 >= 1 = isNeList#(X)
            
            isNeList#(n____(V1,V2)) = 1 >= 1 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
            
            isList#(V) = 1 >= 1 = isNeList#(activate(V))
            
            isList#(n____(V1,V2)) = 1 >= 1 = and#(isList(activate(V1)),n__isList(activate(V2)))
            
            __(__(X,Y),Z) = 16X + 4Y + Z + 5 >= 4X + 4Y + Z + 2 = __(X,__(Y,Z))
            
            __(X,nil()) = 4X + 1 >= X = X
            
            __(nil(),X) = X + 1 >= X = X
            
            and(tt(),X) = X >= X = activate(X)
            
            isList(V) = 0 >= 0 = isNeList(activate(V))
            
            isList(n__nil()) = 0 >= 0 = tt()
            
            isList(n____(V1,V2)) = 0 >= 0 = and(isList(activate(V1)),n__isList(activate(V2)))
            
            isNeList(V) = 0 >= 0 = isQid(activate(V))
            
            isNeList(n____(V1,V2)) = 0 >= 0 = and(isList(activate(V1)),n__isNeList(activate(V2)))
            
            isNeList(n____(V1,V2)) = 0 >= 0 = and(isNeList(activate(V1)),n__isList(activate(V2)))
            
            isNePal(V) = 0 >= 0 = isQid(activate(V))
            
            isNePal(n____(I,n____(P,I))) = 0 >= 0 = and(isQid(activate(I)),n__isPal(activate(P)))
            
            isPal(V) = 0 >= 0 = isNePal(activate(V))
            
            isPal(n__nil()) = 0 >= 0 = tt()
            
            isQid(n__a()) = 0 >= 0 = tt()
            
            isQid(n__e()) = 0 >= 0 = tt()
            
            isQid(n__i()) = 0 >= 0 = tt()
            
            isQid(n__o()) = 0 >= 0 = tt()
            
            isQid(n__u()) = 0 >= 0 = tt()
            
            nil() = 0 >= 0 = n__nil()
            
            __(X1,X2) = 4X1 + X2 + 1 >= 4X1 + X2 + 1 = n____(X1,X2)
            
            isList(X) = 0 >= 0 = n__isList(X)
            
            isNeList(X) = 0 >= 0 = n__isNeList(X)
            
            isPal(X) = 0 >= 0 = n__isPal(X)
            
            a() = 0 >= 0 = n__a()
            
            e() = 1 >= 1 = n__e()
            
            i() = 2 >= 2 = n__i()
            
            o() = 0 >= 0 = n__o()
            
            u() = 4 >= 4 = n__u()
            
            activate(n__nil()) = 0 >= 0 = nil()
            
            activate(n____(X1,X2)) = 4X1 + X2 + 1 >= 4X1 + X2 + 1 = __(activate(X1),activate(X2))
            
            activate(n__isList(X)) = 0 >= 0 = isList(X)
            
            activate(n__isNeList(X)) = 0 >= 0 = isNeList(X)
            
            activate(n__isPal(X)) = 0 >= 0 = isPal(X)
            
            activate(n__a()) = 0 >= 0 = a()
            
            activate(n__e()) = 1 >= 1 = e()
            
            activate(n__i()) = 2 >= 2 = i()
            
            activate(n__o()) = 0 >= 0 = o()
            
            activate(n__u()) = 4 >= 4 = u()
            
            activate(X) = X >= X = X
           problem:
            DPs:
             isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
             and#(tt(),X) -> activate#(X)
             activate#(n__isList(X)) -> isList#(X)
             activate#(n__isNeList(X)) -> isNeList#(X)
             isNeList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isNeList(activate(V2)))
             isList#(V) -> isNeList#(activate(V))
             isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
            TRS:
             __(__(X,Y),Z) -> __(X,__(Y,Z))
             __(X,nil()) -> X
             __(nil(),X) -> X
             and(tt(),X) -> activate(X)
             isList(V) -> isNeList(activate(V))
             isList(n__nil()) -> tt()
             isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
             isNeList(V) -> isQid(activate(V))
             isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
             isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
             isNePal(V) -> isQid(activate(V))
             isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
             isPal(V) -> isNePal(activate(V))
             isPal(n__nil()) -> tt()
             isQid(n__a()) -> tt()
             isQid(n__e()) -> tt()
             isQid(n__i()) -> tt()
             isQid(n__o()) -> tt()
             isQid(n__u()) -> tt()
             nil() -> n__nil()
             __(X1,X2) -> n____(X1,X2)
             isList(X) -> n__isList(X)
             isNeList(X) -> n__isNeList(X)
             isPal(X) -> n__isPal(X)
             a() -> n__a()
             e() -> n__e()
             i() -> n__i()
             o() -> n__o()
             u() -> n__u()
             activate(n__nil()) -> nil()
             activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
             activate(n__isList(X)) -> isList(X)
             activate(n__isNeList(X)) -> isNeList(X)
             activate(n__isPal(X)) -> isPal(X)
             activate(n__a()) -> a()
             activate(n__e()) -> e()
             activate(n__i()) -> i()
             activate(n__o()) -> o()
             activate(n__u()) -> u()
             activate(X) -> X
           Matrix Interpretation Processor: dim=1
            
            interpretation:
             [isNeList#](x0) = x0 + 2,
             
             [isList#](x0) = x0 + 2,
             
             [activate#](x0) = 2x0,
             
             [and#](x0, x1) = 2x1,
             
             [u] = 1,
             
             [o] = 2,
             
             [i] = 0,
             
             [e] = 1,
             
             [a] = 0,
             
             [n__u] = 1,
             
             [n__o] = 2,
             
             [n__i] = 0,
             
             [n__e] = 1,
             
             [n__a] = 0,
             
             [isPal](x0) = 0,
             
             [n__isPal](x0) = 0,
             
             [isNePal](x0) = 0,
             
             [n__isNeList](x0) = 1/2x0 + 1,
             
             [isQid](x0) = 0,
             
             [n__isList](x0) = 1/2x0 + 2,
             
             [n____](x0, x1) = 2x0 + x1 + 2,
             
             [n__nil] = 0,
             
             [isNeList](x0) = 1/2x0 + 1,
             
             [isList](x0) = 1/2x0 + 2,
             
             [activate](x0) = x0,
             
             [and](x0, x1) = x1,
             
             [tt] = 0,
             
             [nil] = 0,
             
             [__](x0, x1) = 2x0 + x1 + 2
            orientation:
             isNeList#(n____(V1,V2)) = 2V1 + V2 + 4 >= V2 + 4 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
             
             and#(tt(),X) = 2X >= 2X = activate#(X)
             
             activate#(n__isList(X)) = X + 4 >= X + 2 = isList#(X)
             
             activate#(n__isNeList(X)) = X + 2 >= X + 2 = isNeList#(X)
             
             isNeList#(n____(V1,V2)) = 2V1 + V2 + 4 >= V2 + 2 = and#(isList(activate(V1)),n__isNeList(activate(V2)))
             
             isList#(V) = V + 2 >= V + 2 = isNeList#(activate(V))
             
             isList#(n____(V1,V2)) = 2V1 + V2 + 4 >= V2 + 4 = and#(isList(activate(V1)),n__isList(activate(V2)))
             
             __(__(X,Y),Z) = 4X + 2Y + Z + 6 >= 2X + 2Y + Z + 4 = __(X,__(Y,Z))
             
             __(X,nil()) = 2X + 2 >= X = X
             
             __(nil(),X) = X + 2 >= X = X
             
             and(tt(),X) = X >= X = activate(X)
             
             isList(V) = 1/2V + 2 >= 1/2V + 1 = isNeList(activate(V))
             
             isList(n__nil()) = 2 >= 0 = tt()
             
             isList(n____(V1,V2)) = V1 + 1/2V2 + 3 >= 1/2V2 + 2 = and(isList(activate(V1)),n__isList(activate(V2)))
             
             isNeList(V) = 1/2V + 1 >= 0 = isQid(activate(V))
             
             isNeList(n____(V1,V2)) = V1 + 1/2V2 + 2 >= 1/2V2 + 1 = and(isList(activate(V1)),n__isNeList(activate(V2)))
             
             isNeList(n____(V1,V2)) = V1 + 1/2V2 + 2 >= 1/2V2 + 2 = and(isNeList(activate(V1)),n__isList(activate(V2)))
             
             isNePal(V) = 0 >= 0 = isQid(activate(V))
             
             isNePal(n____(I,n____(P,I))) = 0 >= 0 = and(isQid(activate(I)),n__isPal(activate(P)))
             
             isPal(V) = 0 >= 0 = isNePal(activate(V))
             
             isPal(n__nil()) = 0 >= 0 = tt()
             
             isQid(n__a()) = 0 >= 0 = tt()
             
             isQid(n__e()) = 0 >= 0 = tt()
             
             isQid(n__i()) = 0 >= 0 = tt()
             
             isQid(n__o()) = 0 >= 0 = tt()
             
             isQid(n__u()) = 0 >= 0 = tt()
             
             nil() = 0 >= 0 = n__nil()
             
             __(X1,X2) = 2X1 + X2 + 2 >= 2X1 + X2 + 2 = n____(X1,X2)
             
             isList(X) = 1/2X + 2 >= 1/2X + 2 = n__isList(X)
             
             isNeList(X) = 1/2X + 1 >= 1/2X + 1 = n__isNeList(X)
             
             isPal(X) = 0 >= 0 = n__isPal(X)
             
             a() = 0 >= 0 = n__a()
             
             e() = 1 >= 1 = n__e()
             
             i() = 0 >= 0 = n__i()
             
             o() = 2 >= 2 = n__o()
             
             u() = 1 >= 1 = n__u()
             
             activate(n__nil()) = 0 >= 0 = nil()
             
             activate(n____(X1,X2)) = 2X1 + X2 + 2 >= 2X1 + X2 + 2 = __(activate(X1),activate(X2))
             
             activate(n__isList(X)) = 1/2X + 2 >= 1/2X + 2 = isList(X)
             
             activate(n__isNeList(X)) = 1/2X + 1 >= 1/2X + 1 = isNeList(X)
             
             activate(n__isPal(X)) = 0 >= 0 = isPal(X)
             
             activate(n__a()) = 0 >= 0 = a()
             
             activate(n__e()) = 1 >= 1 = e()
             
             activate(n__i()) = 0 >= 0 = i()
             
             activate(n__o()) = 2 >= 2 = o()
             
             activate(n__u()) = 1 >= 1 = u()
             
             activate(X) = X >= X = X
            problem:
             DPs:
              isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
              and#(tt(),X) -> activate#(X)
              activate#(n__isNeList(X)) -> isNeList#(X)
              isList#(V) -> isNeList#(activate(V))
              isList#(n____(V1,V2)) -> and#(isList(activate(V1)),n__isList(activate(V2)))
             TRS:
              __(__(X,Y),Z) -> __(X,__(Y,Z))
              __(X,nil()) -> X
              __(nil(),X) -> X
              and(tt(),X) -> activate(X)
              isList(V) -> isNeList(activate(V))
              isList(n__nil()) -> tt()
              isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
              isNeList(V) -> isQid(activate(V))
              isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
              isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
              isNePal(V) -> isQid(activate(V))
              isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
              isPal(V) -> isNePal(activate(V))
              isPal(n__nil()) -> tt()
              isQid(n__a()) -> tt()
              isQid(n__e()) -> tt()
              isQid(n__i()) -> tt()
              isQid(n__o()) -> tt()
              isQid(n__u()) -> tt()
              nil() -> n__nil()
              __(X1,X2) -> n____(X1,X2)
              isList(X) -> n__isList(X)
              isNeList(X) -> n__isNeList(X)
              isPal(X) -> n__isPal(X)
              a() -> n__a()
              e() -> n__e()
              i() -> n__i()
              o() -> n__o()
              u() -> n__u()
              activate(n__nil()) -> nil()
              activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
              activate(n__isList(X)) -> isList(X)
              activate(n__isNeList(X)) -> isNeList(X)
              activate(n__isPal(X)) -> isPal(X)
              activate(n__a()) -> a()
              activate(n__e()) -> e()
              activate(n__i()) -> i()
              activate(n__o()) -> o()
              activate(n__u()) -> u()
              activate(X) -> X
            SCC Processor:
             #sccs: 1
             #rules: 3
             #arcs: 32/25
             DPs:
              isNeList#(n____(V1,V2)) -> and#(isNeList(activate(V1)),n__isList(activate(V2)))
              and#(tt(),X) -> activate#(X)
              activate#(n__isNeList(X)) -> isNeList#(X)
             TRS:
              __(__(X,Y),Z) -> __(X,__(Y,Z))
              __(X,nil()) -> X
              __(nil(),X) -> X
              and(tt(),X) -> activate(X)
              isList(V) -> isNeList(activate(V))
              isList(n__nil()) -> tt()
              isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
              isNeList(V) -> isQid(activate(V))
              isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
              isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
              isNePal(V) -> isQid(activate(V))
              isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
              isPal(V) -> isNePal(activate(V))
              isPal(n__nil()) -> tt()
              isQid(n__a()) -> tt()
              isQid(n__e()) -> tt()
              isQid(n__i()) -> tt()
              isQid(n__o()) -> tt()
              isQid(n__u()) -> tt()
              nil() -> n__nil()
              __(X1,X2) -> n____(X1,X2)
              isList(X) -> n__isList(X)
              isNeList(X) -> n__isNeList(X)
              isPal(X) -> n__isPal(X)
              a() -> n__a()
              e() -> n__e()
              i() -> n__i()
              o() -> n__o()
              u() -> n__u()
              activate(n__nil()) -> nil()
              activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
              activate(n__isList(X)) -> isList(X)
              activate(n__isNeList(X)) -> isNeList(X)
              activate(n__isPal(X)) -> isPal(X)
              activate(n__a()) -> a()
              activate(n__e()) -> e()
              activate(n__i()) -> i()
              activate(n__o()) -> o()
              activate(n__u()) -> u()
              activate(X) -> X
             Arctic Interpretation Processor:
              dimension: 1
              interpretation:
               [isNeList#](x0) = 3,
               
               [activate#](x0) = x0 + 1,
               
               [and#](x0, x1) = x1 + 1,
               
               [u] = 6,
               
               [o] = 5,
               
               [i] = 2,
               
               [e] = 4,
               
               [a] = 5,
               
               [n__u] = 5,
               
               [n__o] = 4,
               
               [n__i] = 2,
               
               [n__e] = 3,
               
               [n__a] = 5,
               
               [isPal](x0) = 1x0 + 4,
               
               [n__isPal](x0) = x0 + 3,
               
               [isNePal](x0) = x0 + 0,
               
               [n__isNeList](x0) = 3,
               
               [isQid](x0) = 0,
               
               [n__isList](x0) = 0,
               
               [n____](x0, x1) = 2x0 + x1 + 5,
               
               [n__nil] = 4,
               
               [isNeList](x0) = 4,
               
               [isList](x0) = 4,
               
               [activate](x0) = 1x0 + 4,
               
               [and](x0, x1) = x0 + 1x1 + 4,
               
               [tt] = 0,
               
               [nil] = 4,
               
               [__](x0, x1) = 2x0 + x1 + 5
              orientation:
               isNeList#(n____(V1,V2)) = 3 >= 1 = and#(isNeList(activate(V1)),n__isList(activate(V2)))
               
               and#(tt(),X) = X + 1 >= X + 1 = activate#(X)
               
               activate#(n__isNeList(X)) = 3 >= 3 = isNeList#(X)
               
               __(__(X,Y),Z) = 4X + 2Y + Z + 7 >= 2X + 2Y + Z + 5 = __(X,__(Y,Z))
               
               __(X,nil()) = 2X + 5 >= X = X
               
               __(nil(),X) = X + 6 >= X = X
               
               and(tt(),X) = 1X + 4 >= 1X + 4 = activate(X)
               
               isList(V) = 4 >= 4 = isNeList(activate(V))
               
               isList(n__nil()) = 4 >= 0 = tt()
               
               isList(n____(V1,V2)) = 4 >= 4 = and(isList(activate(V1)),n__isList(activate(V2)))
               
               isNeList(V) = 4 >= 0 = isQid(activate(V))
               
               isNeList(n____(V1,V2)) = 4 >= 4 = and(isList(activate(V1)),n__isNeList(activate(V2)))
               
               isNeList(n____(V1,V2)) = 4 >= 4 = and(isNeList(activate(V1)),n__isList(activate(V2)))
               
               isNePal(V) = V + 0 >= 0 = isQid(activate(V))
               
               isNePal(n____(I,n____(P,I))) = 2I + 2P + 5 >= 2P + 5 = and(isQid(activate(I)),n__isPal(activate(P)))
               
               isPal(V) = 1V + 4 >= 1V + 4 = isNePal(activate(V))
               
               isPal(n__nil()) = 5 >= 0 = tt()
               
               isQid(n__a()) = 0 >= 0 = tt()
               
               isQid(n__e()) = 0 >= 0 = tt()
               
               isQid(n__i()) = 0 >= 0 = tt()
               
               isQid(n__o()) = 0 >= 0 = tt()
               
               isQid(n__u()) = 0 >= 0 = tt()
               
               nil() = 4 >= 4 = n__nil()
               
               __(X1,X2) = 2X1 + X2 + 5 >= 2X1 + X2 + 5 = n____(X1,X2)
               
               isList(X) = 4 >= 0 = n__isList(X)
               
               isNeList(X) = 4 >= 3 = n__isNeList(X)
               
               isPal(X) = 1X + 4 >= X + 3 = n__isPal(X)
               
               a() = 5 >= 5 = n__a()
               
               e() = 4 >= 3 = n__e()
               
               i() = 2 >= 2 = n__i()
               
               o() = 5 >= 4 = n__o()
               
               u() = 6 >= 5 = n__u()
               
               activate(n__nil()) = 5 >= 4 = nil()
               
               activate(n____(X1,X2)) = 3X1 + 1X2 + 6 >= 3X1 + 1X2 + 6 = __(activate(X1),activate(X2))
               
               activate(n__isList(X)) = 4 >= 4 = isList(X)
               
               activate(n__isNeList(X)) = 4 >= 4 = isNeList(X)
               
               activate(n__isPal(X)) = 1X + 4 >= 1X + 4 = isPal(X)
               
               activate(n__a()) = 6 >= 5 = a()
               
               activate(n__e()) = 4 >= 4 = e()
               
               activate(n__i()) = 4 >= 2 = i()
               
               activate(n__o()) = 5 >= 5 = o()
               
               activate(n__u()) = 6 >= 6 = u()
               
               activate(X) = 1X + 4 >= X = X
              problem:
               DPs:
                and#(tt(),X) -> activate#(X)
                activate#(n__isNeList(X)) -> isNeList#(X)
               TRS:
                __(__(X,Y),Z) -> __(X,__(Y,Z))
                __(X,nil()) -> X
                __(nil(),X) -> X
                and(tt(),X) -> activate(X)
                isList(V) -> isNeList(activate(V))
                isList(n__nil()) -> tt()
                isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
                isNeList(V) -> isQid(activate(V))
                isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
                isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
                isNePal(V) -> isQid(activate(V))
                isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
                isPal(V) -> isNePal(activate(V))
                isPal(n__nil()) -> tt()
                isQid(n__a()) -> tt()
                isQid(n__e()) -> tt()
                isQid(n__i()) -> tt()
                isQid(n__o()) -> tt()
                isQid(n__u()) -> tt()
                nil() -> n__nil()
                __(X1,X2) -> n____(X1,X2)
                isList(X) -> n__isList(X)
                isNeList(X) -> n__isNeList(X)
                isPal(X) -> n__isPal(X)
                a() -> n__a()
                e() -> n__e()
                i() -> n__i()
                o() -> n__o()
                u() -> n__u()
                activate(n__nil()) -> nil()
                activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
                activate(n__isList(X)) -> isList(X)
                activate(n__isNeList(X)) -> isNeList(X)
                activate(n__isPal(X)) -> isPal(X)
                activate(n__a()) -> a()
                activate(n__e()) -> e()
                activate(n__i()) -> i()
                activate(n__o()) -> o()
                activate(n__u()) -> u()
                activate(X) -> X
              SCC Processor:
               #sccs: 0
               #rules: 0
               #arcs: 3/4
               
    
    DPs:
     __#(__(X,Y),Z) -> __#(Y,Z)
     __#(__(X,Y),Z) -> __#(X,__(Y,Z))
    TRS:
     __(__(X,Y),Z) -> __(X,__(Y,Z))
     __(X,nil()) -> X
     __(nil(),X) -> X
     and(tt(),X) -> activate(X)
     isList(V) -> isNeList(activate(V))
     isList(n__nil()) -> tt()
     isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
     isNeList(V) -> isQid(activate(V))
     isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
     isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
     isNePal(V) -> isQid(activate(V))
     isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
     isPal(V) -> isNePal(activate(V))
     isPal(n__nil()) -> tt()
     isQid(n__a()) -> tt()
     isQid(n__e()) -> tt()
     isQid(n__i()) -> tt()
     isQid(n__o()) -> tt()
     isQid(n__u()) -> tt()
     nil() -> n__nil()
     __(X1,X2) -> n____(X1,X2)
     isList(X) -> n__isList(X)
     isNeList(X) -> n__isNeList(X)
     isPal(X) -> n__isPal(X)
     a() -> n__a()
     e() -> n__e()
     i() -> n__i()
     o() -> n__o()
     u() -> n__u()
     activate(n__nil()) -> nil()
     activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
     activate(n__isList(X)) -> isList(X)
     activate(n__isNeList(X)) -> isNeList(X)
     activate(n__isPal(X)) -> isPal(X)
     activate(n__a()) -> a()
     activate(n__e()) -> e()
     activate(n__i()) -> i()
     activate(n__o()) -> o()
     activate(n__u()) -> u()
     activate(X) -> X
    Subterm Criterion Processor:
     simple projection:
      pi(__#) = 0
     problem:
      DPs:
       
      TRS:
       __(__(X,Y),Z) -> __(X,__(Y,Z))
       __(X,nil()) -> X
       __(nil(),X) -> X
       and(tt(),X) -> activate(X)
       isList(V) -> isNeList(activate(V))
       isList(n__nil()) -> tt()
       isList(n____(V1,V2)) -> and(isList(activate(V1)),n__isList(activate(V2)))
       isNeList(V) -> isQid(activate(V))
       isNeList(n____(V1,V2)) -> and(isList(activate(V1)),n__isNeList(activate(V2)))
       isNeList(n____(V1,V2)) -> and(isNeList(activate(V1)),n__isList(activate(V2)))
       isNePal(V) -> isQid(activate(V))
       isNePal(n____(I,n____(P,I))) -> and(isQid(activate(I)),n__isPal(activate(P)))
       isPal(V) -> isNePal(activate(V))
       isPal(n__nil()) -> tt()
       isQid(n__a()) -> tt()
       isQid(n__e()) -> tt()
       isQid(n__i()) -> tt()
       isQid(n__o()) -> tt()
       isQid(n__u()) -> tt()
       nil() -> n__nil()
       __(X1,X2) -> n____(X1,X2)
       isList(X) -> n__isList(X)
       isNeList(X) -> n__isNeList(X)
       isPal(X) -> n__isPal(X)
       a() -> n__a()
       e() -> n__e()
       i() -> n__i()
       o() -> n__o()
       u() -> n__u()
       activate(n__nil()) -> nil()
       activate(n____(X1,X2)) -> __(activate(X1),activate(X2))
       activate(n__isList(X)) -> isList(X)
       activate(n__isNeList(X)) -> isNeList(X)
       activate(n__isPal(X)) -> isPal(X)
       activate(n__a()) -> a()
       activate(n__e()) -> e()
       activate(n__i()) -> i()
       activate(n__o()) -> o()
       activate(n__u()) -> u()
       activate(X) -> X
     Qed