MAYBE
TRS:
 {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                       mark(nil()) -> active(nil()),
                 mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                        mark(tt()) -> active(tt()),
                 mark(isNeList(X)) -> active(isNeList(X)),
                   mark(isList(X)) -> active(isList(X)),
                    mark(isQid(X)) -> active(isQid(X)),
                  mark(isNePal(X)) -> active(isNePal(X)),
                    mark(isPal(X)) -> active(isPal(X)),
                         mark(a()) -> active(a()),
                         mark(e()) -> active(e()),
                         mark(i()) -> active(i()),
                         mark(o()) -> active(o()),
                         mark(u()) -> active(u()),
                  __(X1, mark(X2)) -> __(X1, X2),
                __(X1, active(X2)) -> __(X1, X2),
                  __(mark(X1), X2) -> __(X1, X2),
                __(active(X1), X2) -> __(X1, X2),
              active(__(X, nil())) -> mark(X),
           active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
              active(__(nil(), X)) -> mark(X),
              active(and(tt(), X)) -> mark(X),
               active(isNeList(V)) -> mark(isQid(V)),
      active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
      active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                 active(isList(V)) -> mark(isNeList(V)),
        active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
             active(isList(nil())) -> mark(tt()),
                active(isQid(a())) -> mark(tt()),
                active(isQid(e())) -> mark(tt()),
                active(isQid(i())) -> mark(tt()),
                active(isQid(o())) -> mark(tt()),
                active(isQid(u())) -> mark(tt()),
                active(isNePal(V)) -> mark(isQid(V)),
  active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                  active(isPal(V)) -> mark(isNePal(V)),
              active(isPal(nil())) -> mark(tt()),
                 and(X1, mark(X2)) -> and(X1, X2),
               and(X1, active(X2)) -> and(X1, X2),
                 and(mark(X1), X2) -> and(X1, X2),
               and(active(X1), X2) -> and(X1, X2),
                 isNeList(mark(X)) -> isNeList(X),
               isNeList(active(X)) -> isNeList(X),
                   isList(mark(X)) -> isList(X),
                 isList(active(X)) -> isList(X),
                    isQid(mark(X)) -> isQid(X),
                  isQid(active(X)) -> isQid(X),
                  isNePal(mark(X)) -> isNePal(X),
                isNePal(active(X)) -> isNePal(X),
                    isPal(mark(X)) -> isPal(X),
                  isPal(active(X)) -> isPal(X)}
 DP:
  Strict:
   {                mark#(__(X1, X2)) -> mark#(X1),
                    mark#(__(X1, X2)) -> mark#(X2),
                    mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)),
                    mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                         mark#(nil()) -> active#(nil()),
                   mark#(and(X1, X2)) -> mark#(X1),
                   mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                   mark#(and(X1, X2)) -> and#(mark(X1), X2),
                          mark#(tt()) -> active#(tt()),
                   mark#(isNeList(X)) -> active#(isNeList(X)),
                     mark#(isList(X)) -> active#(isList(X)),
                      mark#(isQid(X)) -> active#(isQid(X)),
                    mark#(isNePal(X)) -> active#(isNePal(X)),
                      mark#(isPal(X)) -> active#(isPal(X)),
                           mark#(a()) -> active#(a()),
                           mark#(e()) -> active#(e()),
                           mark#(i()) -> active#(i()),
                           mark#(o()) -> active#(o()),
                           mark#(u()) -> active#(u()),
                    __#(X1, mark(X2)) -> __#(X1, X2),
                  __#(X1, active(X2)) -> __#(X1, X2),
                    __#(mark(X1), X2) -> __#(X1, X2),
                  __#(active(X1), X2) -> __#(X1, X2),
                active#(__(X, nil())) -> mark#(X),
             active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
             active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)),
             active#(__(__(X, Y), Z)) -> __#(Y, Z),
                active#(__(nil(), X)) -> mark#(X),
                active#(and(tt(), X)) -> mark#(X),
                 active#(isNeList(V)) -> mark#(isQid(V)),
                 active#(isNeList(V)) -> isQid#(V),
        active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
        active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
        active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)),
        active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)),
        active#(isNeList(__(V1, V2))) -> isNeList#(V1),
        active#(isNeList(__(V1, V2))) -> isNeList#(V2),
        active#(isNeList(__(V1, V2))) -> isList#(V1),
        active#(isNeList(__(V1, V2))) -> isList#(V2),
                   active#(isList(V)) -> mark#(isNeList(V)),
                   active#(isList(V)) -> isNeList#(V),
          active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
          active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)),
          active#(isList(__(V1, V2))) -> isList#(V1),
          active#(isList(__(V1, V2))) -> isList#(V2),
               active#(isList(nil())) -> mark#(tt()),
                  active#(isQid(a())) -> mark#(tt()),
                  active#(isQid(e())) -> mark#(tt()),
                  active#(isQid(i())) -> mark#(tt()),
                  active#(isQid(o())) -> mark#(tt()),
                  active#(isQid(u())) -> mark#(tt()),
                  active#(isNePal(V)) -> mark#(isQid(V)),
                  active#(isNePal(V)) -> isQid#(V),
    active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
    active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)),
    active#(isNePal(__(I, __(P, I)))) -> isQid#(I),
    active#(isNePal(__(I, __(P, I)))) -> isPal#(P),
                    active#(isPal(V)) -> mark#(isNePal(V)),
                    active#(isPal(V)) -> isNePal#(V),
                active#(isPal(nil())) -> mark#(tt()),
                   and#(X1, mark(X2)) -> and#(X1, X2),
                 and#(X1, active(X2)) -> and#(X1, X2),
                   and#(mark(X1), X2) -> and#(X1, X2),
                 and#(active(X1), X2) -> and#(X1, X2),
                   isNeList#(mark(X)) -> isNeList#(X),
                 isNeList#(active(X)) -> isNeList#(X),
                     isList#(mark(X)) -> isList#(X),
                   isList#(active(X)) -> isList#(X),
                      isQid#(mark(X)) -> isQid#(X),
                    isQid#(active(X)) -> isQid#(X),
                    isNePal#(mark(X)) -> isNePal#(X),
                  isNePal#(active(X)) -> isNePal#(X),
                      isPal#(mark(X)) -> isPal#(X),
                    isPal#(active(X)) -> isPal#(X)}
  Weak:
  {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                        mark(nil()) -> active(nil()),
                  mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                         mark(tt()) -> active(tt()),
                  mark(isNeList(X)) -> active(isNeList(X)),
                    mark(isList(X)) -> active(isList(X)),
                     mark(isQid(X)) -> active(isQid(X)),
                   mark(isNePal(X)) -> active(isNePal(X)),
                     mark(isPal(X)) -> active(isPal(X)),
                          mark(a()) -> active(a()),
                          mark(e()) -> active(e()),
                          mark(i()) -> active(i()),
                          mark(o()) -> active(o()),
                          mark(u()) -> active(u()),
                   __(X1, mark(X2)) -> __(X1, X2),
                 __(X1, active(X2)) -> __(X1, X2),
                   __(mark(X1), X2) -> __(X1, X2),
                 __(active(X1), X2) -> __(X1, X2),
               active(__(X, nil())) -> mark(X),
            active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
               active(__(nil(), X)) -> mark(X),
               active(and(tt(), X)) -> mark(X),
                active(isNeList(V)) -> mark(isQid(V)),
       active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
       active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                  active(isList(V)) -> mark(isNeList(V)),
         active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
              active(isList(nil())) -> mark(tt()),
                 active(isQid(a())) -> mark(tt()),
                 active(isQid(e())) -> mark(tt()),
                 active(isQid(i())) -> mark(tt()),
                 active(isQid(o())) -> mark(tt()),
                 active(isQid(u())) -> mark(tt()),
                 active(isNePal(V)) -> mark(isQid(V)),
   active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                   active(isPal(V)) -> mark(isNePal(V)),
               active(isPal(nil())) -> mark(tt()),
                  and(X1, mark(X2)) -> and(X1, X2),
                and(X1, active(X2)) -> and(X1, X2),
                  and(mark(X1), X2) -> and(X1, X2),
                and(active(X1), X2) -> and(X1, X2),
                  isNeList(mark(X)) -> isNeList(X),
                isNeList(active(X)) -> isNeList(X),
                    isList(mark(X)) -> isList(X),
                  isList(active(X)) -> isList(X),
                     isQid(mark(X)) -> isQid(X),
                   isQid(active(X)) -> isQid(X),
                   isNePal(mark(X)) -> isNePal(X),
                 isNePal(active(X)) -> isNePal(X),
                     isPal(mark(X)) -> isPal(X),
                   isPal(active(X)) -> isPal(X)}
  EDG:
   {
    (active#(isList(V)) -> isNeList#(V), isNeList#(active(X)) -> isNeList#(X))
    (active#(isList(V)) -> isNeList#(V), isNeList#(mark(X)) -> isNeList#(X))
    (active#(isPal(V)) -> isNePal#(V), isNePal#(active(X)) -> isNePal#(X))
    (active#(isPal(V)) -> isNePal#(V), isNePal#(mark(X)) -> isNePal#(X))
    (active#(__(nil(), X)) -> mark#(X), mark#(u()) -> active#(u()))
    (active#(__(nil(), X)) -> mark#(X), mark#(o()) -> active#(o()))
    (active#(__(nil(), X)) -> mark#(X), mark#(i()) -> active#(i()))
    (active#(__(nil(), X)) -> mark#(X), mark#(e()) -> active#(e()))
    (active#(__(nil(), X)) -> mark#(X), mark#(a()) -> active#(a()))
    (active#(__(nil(), X)) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(__(nil(), X)) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(__(nil(), X)) -> mark#(X), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(__(nil(), X)) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
    (active#(__(nil(), X)) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(__(nil(), X)) -> mark#(X), mark#(tt()) -> active#(tt()))
    (active#(__(nil(), X)) -> mark#(X), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(__(nil(), X)) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(__(nil(), X)) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
    (active#(__(nil(), X)) -> mark#(X), mark#(nil()) -> active#(nil()))
    (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
    (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
    (isNeList#(mark(X)) -> isNeList#(X), isNeList#(active(X)) -> isNeList#(X))
    (isNeList#(mark(X)) -> isNeList#(X), isNeList#(mark(X)) -> isNeList#(X))
    (isList#(mark(X)) -> isList#(X), isList#(active(X)) -> isList#(X))
    (isList#(mark(X)) -> isList#(X), isList#(mark(X)) -> isList#(X))
    (isQid#(mark(X)) -> isQid#(X), isQid#(active(X)) -> isQid#(X))
    (isQid#(mark(X)) -> isQid#(X), isQid#(mark(X)) -> isQid#(X))
    (isNePal#(mark(X)) -> isNePal#(X), isNePal#(active(X)) -> isNePal#(X))
    (isNePal#(mark(X)) -> isNePal#(X), isNePal#(mark(X)) -> isNePal#(X))
    (isPal#(mark(X)) -> isPal#(X), isPal#(active(X)) -> isPal#(X))
    (isPal#(mark(X)) -> isPal#(X), isPal#(mark(X)) -> isPal#(X))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(nil())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> isNePal#(V))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> isQid#(V))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isQid(u())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isQid(o())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isQid(i())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isQid(e())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isQid(a())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(nil())) -> mark#(tt()))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> isNeList#(V))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> isQid#(V))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(and(tt(), X)) -> mark#(X))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(nil(), X)) -> mark#(X))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(X, nil())) -> mark#(X))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isPal(nil())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isPal(V)) -> isNePal#(V))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNePal(V)) -> isQid#(V))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isQid(u())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isQid(o())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isQid(i())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isQid(e())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isQid(a())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(nil())) -> mark#(tt()))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(V)) -> isNeList#(V))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(V)) -> isQid#(V))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(and(tt(), X)) -> mark#(X))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(__(nil(), X)) -> mark#(X))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(isQid(X)) -> active#(isQid(X)), active#(__(X, nil())) -> mark#(X))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(nil())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> isNePal#(V))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> isQid#(V))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isQid(u())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isQid(o())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isQid(i())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isQid(e())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isQid(a())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(nil())) -> mark#(tt()))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> isNeList#(V))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> isQid#(V))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(and(tt(), X)) -> mark#(X))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(__(nil(), X)) -> mark#(X))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(isPal(X)) -> active#(isPal(X)), active#(__(X, nil())) -> mark#(X))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(u()) -> active#(u()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(o()) -> active#(o()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(i()) -> active#(i()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(e()) -> active#(e()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(a()) -> active#(a()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(isQid(X)) -> active#(isQid(X)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(tt()) -> active#(tt()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(nil()) -> active#(nil()))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isNeList(__(V1, V2))) -> isList#(V2), isList#(active(X)) -> isList#(X))
    (active#(isNeList(__(V1, V2))) -> isList#(V2), isList#(mark(X)) -> isList#(X))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(nil())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> isNePal#(V))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> isQid#(V))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isQid(u())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isQid(o())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isQid(i())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isQid(e())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isQid(a())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(nil())) -> mark#(tt()))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> isNeList#(V))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> isQid#(V))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(and(tt(), X)) -> mark#(X))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(nil(), X)) -> mark#(X))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(X, nil())) -> mark#(X))
    (active#(isNePal(__(I, __(P, I)))) -> isPal#(P), isPal#(active(X)) -> isPal#(X))
    (active#(isNePal(__(I, __(P, I)))) -> isPal#(P), isPal#(mark(X)) -> isPal#(X))
    (active#(isNeList(__(V1, V2))) -> isList#(V1), isList#(active(X)) -> isList#(X))
    (active#(isNeList(__(V1, V2))) -> isList#(V1), isList#(mark(X)) -> isList#(X))
    (mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)), __#(active(X1), X2) -> __#(X1, X2))
    (mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)), __#(mark(X1), X2) -> __#(X1, X2))
    (mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)), __#(X1, active(X2)) -> __#(X1, X2))
    (mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)), __#(X1, mark(X2)) -> __#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)), and#(active(X1), X2) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)), and#(mark(X1), X2) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)), and#(X1, active(X2)) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)), and#(X1, mark(X2)) -> and#(X1, X2))
    (active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)), and#(active(X1), X2) -> and#(X1, X2))
    (active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)), and#(mark(X1), X2) -> and#(X1, X2))
    (active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)), and#(X1, active(X2)) -> and#(X1, X2))
    (active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)), and#(X1, mark(X2)) -> and#(X1, X2))
    (active#(isQid(a())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (active#(isQid(i())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (active#(isQid(u())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(u()) -> active#(u()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(o()) -> active#(o()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(i()) -> active#(i()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(e()) -> active#(e()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(a()) -> active#(a()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(isPal(X)) -> active#(isPal(X)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(isNePal(X)) -> active#(isNePal(X)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(isQid(X)) -> active#(isQid(X)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(isList(X)) -> active#(isList(X)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(isNeList(X)) -> active#(isNeList(X)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(tt()) -> active#(tt()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> mark#(X1))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(nil()) -> active#(nil()))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X2))
    (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X1))
    (__#(X1, active(X2)) -> __#(X1, X2), __#(active(X1), X2) -> __#(X1, X2))
    (__#(X1, active(X2)) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))
    (__#(X1, active(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
    (__#(X1, active(X2)) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
    (__#(active(X1), X2) -> __#(X1, X2), __#(active(X1), X2) -> __#(X1, X2))
    (__#(active(X1), X2) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))
    (__#(active(X1), X2) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
    (__#(active(X1), X2) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
    (and#(X1, active(X2)) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))
    (and#(X1, active(X2)) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
    (and#(X1, active(X2)) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
    (and#(X1, active(X2)) -> and#(X1, X2), and#(X1, mark(X2)) -> and#(X1, X2))
    (and#(active(X1), X2) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))
    (and#(active(X1), X2) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
    (and#(active(X1), X2) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
    (and#(active(X1), X2) -> and#(X1, X2), and#(X1, mark(X2)) -> and#(X1, X2))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(nil())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> isNePal#(V))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> isQid#(V))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isQid(u())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isQid(o())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isQid(i())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isQid(e())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isQid(a())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(nil())) -> mark#(tt()))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> isNeList#(V))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> isQid#(V))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(and(tt(), X)) -> mark#(X))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(nil(), X)) -> mark#(X))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(X, nil())) -> mark#(X))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isList(X)) -> active#(isList(X)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X2))
    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isList(X)) -> active#(isList(X)))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isList(X)) -> active#(isList(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(__(__(X, Y), Z)) -> __#(Y, Z), __#(X1, mark(X2)) -> __#(X1, X2))
    (active#(__(__(X, Y), Z)) -> __#(Y, Z), __#(X1, active(X2)) -> __#(X1, X2))
    (active#(__(__(X, Y), Z)) -> __#(Y, Z), __#(mark(X1), X2) -> __#(X1, X2))
    (active#(__(__(X, Y), Z)) -> __#(Y, Z), __#(active(X1), X2) -> __#(X1, X2))
    (active#(isNePal(__(I, __(P, I)))) -> isQid#(I), isQid#(mark(X)) -> isQid#(X))
    (active#(isNePal(__(I, __(P, I)))) -> isQid#(I), isQid#(active(X)) -> isQid#(X))
    (and#(mark(X1), X2) -> and#(X1, X2), and#(X1, mark(X2)) -> and#(X1, X2))
    (and#(mark(X1), X2) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
    (and#(mark(X1), X2) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
    (and#(mark(X1), X2) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))
    (and#(X1, mark(X2)) -> and#(X1, X2), and#(X1, mark(X2)) -> and#(X1, X2))
    (and#(X1, mark(X2)) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
    (and#(X1, mark(X2)) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
    (and#(X1, mark(X2)) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))
    (__#(mark(X1), X2) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
    (__#(mark(X1), X2) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
    (__#(mark(X1), X2) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))
    (__#(mark(X1), X2) -> __#(X1, X2), __#(active(X1), X2) -> __#(X1, X2))
    (__#(X1, mark(X2)) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
    (__#(X1, mark(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
    (__#(X1, mark(X2)) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))
    (__#(X1, mark(X2)) -> __#(X1, X2), __#(active(X1), X2) -> __#(X1, X2))
    (active#(isPal(nil())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (active#(isQid(o())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (active#(isQid(e())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (active#(isList(nil())) -> mark#(tt()), mark#(tt()) -> active#(tt()))
    (mark#(and(X1, X2)) -> and#(mark(X1), X2), and#(X1, mark(X2)) -> and#(X1, X2))
    (mark#(and(X1, X2)) -> and#(mark(X1), X2), and#(X1, active(X2)) -> and#(X1, X2))
    (mark#(and(X1, X2)) -> and#(mark(X1), X2), and#(mark(X1), X2) -> and#(X1, X2))
    (mark#(and(X1, X2)) -> and#(mark(X1), X2), and#(active(X1), X2) -> and#(X1, X2))
    (active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)), and#(X1, mark(X2)) -> and#(X1, X2))
    (active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)), and#(X1, active(X2)) -> and#(X1, X2))
    (active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)), and#(mark(X1), X2) -> and#(X1, X2))
    (active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)), and#(active(X1), X2) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)), and#(X1, mark(X2)) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)), and#(X1, active(X2)) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)), and#(mark(X1), X2) -> and#(X1, X2))
    (active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)), and#(active(X1), X2) -> and#(X1, X2))
    (active#(isList(__(V1, V2))) -> isList#(V1), isList#(mark(X)) -> isList#(X))
    (active#(isList(__(V1, V2))) -> isList#(V1), isList#(active(X)) -> isList#(X))
    (active#(isNeList(__(V1, V2))) -> isNeList#(V1), isNeList#(mark(X)) -> isNeList#(X))
    (active#(isNeList(__(V1, V2))) -> isNeList#(V1), isNeList#(active(X)) -> isNeList#(X))
    (active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)), __#(X1, mark(X2)) -> __#(X1, X2))
    (active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)), __#(X1, active(X2)) -> __#(X1, X2))
    (active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)), __#(mark(X1), X2) -> __#(X1, X2))
    (active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)), __#(active(X1), X2) -> __#(X1, X2))
    (active#(isList(__(V1, V2))) -> isList#(V2), isList#(mark(X)) -> isList#(X))
    (active#(isList(__(V1, V2))) -> isList#(V2), isList#(active(X)) -> isList#(X))
    (active#(isNeList(__(V1, V2))) -> isNeList#(V2), isNeList#(mark(X)) -> isNeList#(X))
    (active#(isNeList(__(V1, V2))) -> isNeList#(V2), isNeList#(active(X)) -> isNeList#(X))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(nil()) -> active#(nil()))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(tt()) -> active#(tt()))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(isQid(X)) -> active#(isQid(X)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(a()) -> active#(a()))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(e()) -> active#(e()))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(i()) -> active#(i()))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(o()) -> active#(o()))
    (mark#(__(X1, X2)) -> mark#(X1), mark#(u()) -> active#(u()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(X, nil())) -> mark#(X))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(nil(), X)) -> mark#(X))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(and(tt(), X)) -> mark#(X))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> isQid#(V))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> isNeList#(V))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(nil())) -> mark#(tt()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isQid(a())) -> mark#(tt()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isQid(e())) -> mark#(tt()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isQid(i())) -> mark#(tt()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isQid(o())) -> mark#(tt()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isQid(u())) -> mark#(tt()))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> isQid#(V))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> isNePal#(V))
    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(nil())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(__(X, nil())) -> mark#(X))
    (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
    (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> __#(X, __(Y, Z)))
    (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> __#(Y, Z))
    (mark#(isList(X)) -> active#(isList(X)), active#(__(nil(), X)) -> mark#(X))
    (mark#(isList(X)) -> active#(isList(X)), active#(and(tt(), X)) -> mark#(X))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(V)) -> isQid#(V))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> and#(isNeList(V1), isList(V2)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> and#(isList(V1), isNeList(V2)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V1))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> isNeList#(V2))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> isList#(V1))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> isList#(V2))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(V)) -> mark#(isNeList(V)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(V)) -> isNeList#(V))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> and#(isList(V1), isList(V2)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> isList#(V1))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> isList#(V2))
    (mark#(isList(X)) -> active#(isList(X)), active#(isList(nil())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(isQid(a())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(isQid(e())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(isQid(i())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(isQid(o())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(isQid(u())) -> mark#(tt()))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(V)) -> isQid#(V))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> and#(isQid(I), isPal(P)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> isQid#(I))
    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> isPal#(P))
    (mark#(isList(X)) -> active#(isList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
    (mark#(isList(X)) -> active#(isList(X)), active#(isPal(V)) -> isNePal#(V))
    (mark#(isList(X)) -> active#(isList(X)), active#(isPal(nil())) -> mark#(tt()))
    (isPal#(active(X)) -> isPal#(X), isPal#(mark(X)) -> isPal#(X))
    (isPal#(active(X)) -> isPal#(X), isPal#(active(X)) -> isPal#(X))
    (isNePal#(active(X)) -> isNePal#(X), isNePal#(mark(X)) -> isNePal#(X))
    (isNePal#(active(X)) -> isNePal#(X), isNePal#(active(X)) -> isNePal#(X))
    (isQid#(active(X)) -> isQid#(X), isQid#(mark(X)) -> isQid#(X))
    (isQid#(active(X)) -> isQid#(X), isQid#(active(X)) -> isQid#(X))
    (isList#(active(X)) -> isList#(X), isList#(mark(X)) -> isList#(X))
    (isList#(active(X)) -> isList#(X), isList#(active(X)) -> isList#(X))
    (isNeList#(active(X)) -> isNeList#(X), isNeList#(mark(X)) -> isNeList#(X))
    (isNeList#(active(X)) -> isNeList#(X), isNeList#(active(X)) -> isNeList#(X))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isList(X)) -> active#(isList(X)))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X1))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X2))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isList(X)) -> active#(isList(X)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
    (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
    (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(and(tt(), X)) -> mark#(X), mark#(nil()) -> active#(nil()))
    (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
    (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(and(tt(), X)) -> mark#(X), mark#(tt()) -> active#(tt()))
    (active#(and(tt(), X)) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(and(tt(), X)) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
    (active#(and(tt(), X)) -> mark#(X), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(and(tt(), X)) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(and(tt(), X)) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(and(tt(), X)) -> mark#(X), mark#(a()) -> active#(a()))
    (active#(and(tt(), X)) -> mark#(X), mark#(e()) -> active#(e()))
    (active#(and(tt(), X)) -> mark#(X), mark#(i()) -> active#(i()))
    (active#(and(tt(), X)) -> mark#(X), mark#(o()) -> active#(o()))
    (active#(and(tt(), X)) -> mark#(X), mark#(u()) -> active#(u()))
    (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
    (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
    (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> __#(mark(X1), mark(X2)))
    (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
    (active#(__(X, nil())) -> mark#(X), mark#(nil()) -> active#(nil()))
    (active#(__(X, nil())) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
    (active#(__(X, nil())) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
    (active#(__(X, nil())) -> mark#(X), mark#(and(X1, X2)) -> and#(mark(X1), X2))
    (active#(__(X, nil())) -> mark#(X), mark#(tt()) -> active#(tt()))
    (active#(__(X, nil())) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
    (active#(__(X, nil())) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
    (active#(__(X, nil())) -> mark#(X), mark#(isQid(X)) -> active#(isQid(X)))
    (active#(__(X, nil())) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
    (active#(__(X, nil())) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
    (active#(__(X, nil())) -> mark#(X), mark#(a()) -> active#(a()))
    (active#(__(X, nil())) -> mark#(X), mark#(e()) -> active#(e()))
    (active#(__(X, nil())) -> mark#(X), mark#(i()) -> active#(i()))
    (active#(__(X, nil())) -> mark#(X), mark#(o()) -> active#(o()))
    (active#(__(X, nil())) -> mark#(X), mark#(u()) -> active#(u()))
    (active#(isNePal(V)) -> isQid#(V), isQid#(mark(X)) -> isQid#(X))
    (active#(isNePal(V)) -> isQid#(V), isQid#(active(X)) -> isQid#(X))
    (active#(isNeList(V)) -> isQid#(V), isQid#(mark(X)) -> isQid#(X))
    (active#(isNeList(V)) -> isQid#(V), isQid#(active(X)) -> isQid#(X))
   }
   SCCS:
    Scc:
     {  isPal#(mark(X)) -> isPal#(X),
      isPal#(active(X)) -> isPal#(X)}
    Scc:
     {  isNePal#(mark(X)) -> isNePal#(X),
      isNePal#(active(X)) -> isNePal#(X)}
    Scc:
     {  isQid#(mark(X)) -> isQid#(X),
      isQid#(active(X)) -> isQid#(X)}
    Scc:
     {  isList#(mark(X)) -> isList#(X),
      isList#(active(X)) -> isList#(X)}
    Scc:
     {  isNeList#(mark(X)) -> isNeList#(X),
      isNeList#(active(X)) -> isNeList#(X)}
    Scc:
     {  and#(X1, mark(X2)) -> and#(X1, X2),
      and#(X1, active(X2)) -> and#(X1, X2),
        and#(mark(X1), X2) -> and#(X1, X2),
      and#(active(X1), X2) -> and#(X1, X2)}
    Scc:
     {  __#(X1, mark(X2)) -> __#(X1, X2),
      __#(X1, active(X2)) -> __#(X1, X2),
        __#(mark(X1), X2) -> __#(X1, X2),
      __#(active(X1), X2) -> __#(X1, X2)}
    Scc:
     {                mark#(__(X1, X2)) -> mark#(X1),
                      mark#(__(X1, X2)) -> mark#(X2),
                      mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                     mark#(and(X1, X2)) -> mark#(X1),
                     mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                     mark#(isNeList(X)) -> active#(isNeList(X)),
                       mark#(isList(X)) -> active#(isList(X)),
                        mark#(isQid(X)) -> active#(isQid(X)),
                      mark#(isNePal(X)) -> active#(isNePal(X)),
                        mark#(isPal(X)) -> active#(isPal(X)),
                  active#(__(X, nil())) -> mark#(X),
               active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                  active#(__(nil(), X)) -> mark#(X),
                  active#(and(tt(), X)) -> mark#(X),
                   active#(isNeList(V)) -> mark#(isQid(V)),
          active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
          active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                     active#(isList(V)) -> mark#(isNeList(V)),
            active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                    active#(isNePal(V)) -> mark#(isQid(V)),
      active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                      active#(isPal(V)) -> mark#(isNePal(V))}
    SCC:
     Strict:
      {  isPal#(mark(X)) -> isPal#(X),
       isPal#(active(X)) -> isPal#(X)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(isPal#) = 0
      Strict:
       {isPal#(active(X)) -> isPal#(X)}
      EDG:
       {(isPal#(active(X)) -> isPal#(X), isPal#(active(X)) -> isPal#(X))}
       SCCS:
        Scc:
         {isPal#(active(X)) -> isPal#(X)}
        SCC:
         Strict:
          {isPal#(active(X)) -> isPal#(X)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(isPal#) = 0
          Strict:
           {}
          Qed
    SCC:
     Strict:
      {  isNePal#(mark(X)) -> isNePal#(X),
       isNePal#(active(X)) -> isNePal#(X)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(isNePal#) = 0
      Strict:
       {isNePal#(active(X)) -> isNePal#(X)}
      EDG:
       {(isNePal#(active(X)) -> isNePal#(X), isNePal#(active(X)) -> isNePal#(X))}
       SCCS:
        Scc:
         {isNePal#(active(X)) -> isNePal#(X)}
        SCC:
         Strict:
          {isNePal#(active(X)) -> isNePal#(X)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(isNePal#) = 0
          Strict:
           {}
          Qed
    SCC:
     Strict:
      {  isQid#(mark(X)) -> isQid#(X),
       isQid#(active(X)) -> isQid#(X)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(isQid#) = 0
      Strict:
       {isQid#(active(X)) -> isQid#(X)}
      EDG:
       {(isQid#(active(X)) -> isQid#(X), isQid#(active(X)) -> isQid#(X))}
       SCCS:
        Scc:
         {isQid#(active(X)) -> isQid#(X)}
        SCC:
         Strict:
          {isQid#(active(X)) -> isQid#(X)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(isQid#) = 0
          Strict:
           {}
          Qed
    SCC:
     Strict:
      {  isList#(mark(X)) -> isList#(X),
       isList#(active(X)) -> isList#(X)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(isList#) = 0
      Strict:
       {isList#(active(X)) -> isList#(X)}
      EDG:
       {(isList#(active(X)) -> isList#(X), isList#(active(X)) -> isList#(X))}
       SCCS:
        Scc:
         {isList#(active(X)) -> isList#(X)}
        SCC:
         Strict:
          {isList#(active(X)) -> isList#(X)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(isList#) = 0
          Strict:
           {}
          Qed
    SCC:
     Strict:
      {  isNeList#(mark(X)) -> isNeList#(X),
       isNeList#(active(X)) -> isNeList#(X)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(isNeList#) = 0
      Strict:
       {isNeList#(active(X)) -> isNeList#(X)}
      EDG:
       {(isNeList#(active(X)) -> isNeList#(X), isNeList#(active(X)) -> isNeList#(X))}
       SCCS:
        Scc:
         {isNeList#(active(X)) -> isNeList#(X)}
        SCC:
         Strict:
          {isNeList#(active(X)) -> isNeList#(X)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(isNeList#) = 0
          Strict:
           {}
          Qed
    SCC:
     Strict:
      {  and#(X1, mark(X2)) -> and#(X1, X2),
       and#(X1, active(X2)) -> and#(X1, X2),
         and#(mark(X1), X2) -> and#(X1, X2),
       and#(active(X1), X2) -> and#(X1, X2)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(and#) = 1
      Strict:
       {and#(X1, active(X2)) -> and#(X1, X2),
          and#(mark(X1), X2) -> and#(X1, X2),
        and#(active(X1), X2) -> and#(X1, X2)}
      EDG:
       {(and#(mark(X1), X2) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))
        (and#(mark(X1), X2) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
        (and#(mark(X1), X2) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
        (and#(active(X1), X2) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
        (and#(active(X1), X2) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
        (and#(active(X1), X2) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))
        (and#(X1, active(X2)) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
        (and#(X1, active(X2)) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
        (and#(X1, active(X2)) -> and#(X1, X2), and#(active(X1), X2) -> and#(X1, X2))}
       SCCS:
        Scc:
         {and#(X1, active(X2)) -> and#(X1, X2),
            and#(mark(X1), X2) -> and#(X1, X2),
          and#(active(X1), X2) -> and#(X1, X2)}
        SCC:
         Strict:
          {and#(X1, active(X2)) -> and#(X1, X2),
             and#(mark(X1), X2) -> and#(X1, X2),
           and#(active(X1), X2) -> and#(X1, X2)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(and#) = 0
          Strict:
           {and#(X1, active(X2)) -> and#(X1, X2),
              and#(mark(X1), X2) -> and#(X1, X2)}
          EDG:
           {(and#(mark(X1), X2) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))
            (and#(mark(X1), X2) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
            (and#(X1, active(X2)) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))
            (and#(X1, active(X2)) -> and#(X1, X2), and#(mark(X1), X2) -> and#(X1, X2))}
           SCCS:
            Scc:
             {and#(X1, active(X2)) -> and#(X1, X2),
                and#(mark(X1), X2) -> and#(X1, X2)}
            SCC:
             Strict:
              {and#(X1, active(X2)) -> and#(X1, X2),
                 and#(mark(X1), X2) -> and#(X1, X2)}
             Weak:
             {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                   mark(nil()) -> active(nil()),
                             mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                    mark(tt()) -> active(tt()),
                             mark(isNeList(X)) -> active(isNeList(X)),
                               mark(isList(X)) -> active(isList(X)),
                                mark(isQid(X)) -> active(isQid(X)),
                              mark(isNePal(X)) -> active(isNePal(X)),
                                mark(isPal(X)) -> active(isPal(X)),
                                     mark(a()) -> active(a()),
                                     mark(e()) -> active(e()),
                                     mark(i()) -> active(i()),
                                     mark(o()) -> active(o()),
                                     mark(u()) -> active(u()),
                              __(X1, mark(X2)) -> __(X1, X2),
                            __(X1, active(X2)) -> __(X1, X2),
                              __(mark(X1), X2) -> __(X1, X2),
                            __(active(X1), X2) -> __(X1, X2),
                          active(__(X, nil())) -> mark(X),
                       active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                          active(__(nil(), X)) -> mark(X),
                          active(and(tt(), X)) -> mark(X),
                           active(isNeList(V)) -> mark(isQid(V)),
                  active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                  active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                             active(isList(V)) -> mark(isNeList(V)),
                    active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                         active(isList(nil())) -> mark(tt()),
                            active(isQid(a())) -> mark(tt()),
                            active(isQid(e())) -> mark(tt()),
                            active(isQid(i())) -> mark(tt()),
                            active(isQid(o())) -> mark(tt()),
                            active(isQid(u())) -> mark(tt()),
                            active(isNePal(V)) -> mark(isQid(V)),
              active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                              active(isPal(V)) -> mark(isNePal(V)),
                          active(isPal(nil())) -> mark(tt()),
                             and(X1, mark(X2)) -> and(X1, X2),
                           and(X1, active(X2)) -> and(X1, X2),
                             and(mark(X1), X2) -> and(X1, X2),
                           and(active(X1), X2) -> and(X1, X2),
                             isNeList(mark(X)) -> isNeList(X),
                           isNeList(active(X)) -> isNeList(X),
                               isList(mark(X)) -> isList(X),
                             isList(active(X)) -> isList(X),
                                isQid(mark(X)) -> isQid(X),
                              isQid(active(X)) -> isQid(X),
                              isNePal(mark(X)) -> isNePal(X),
                            isNePal(active(X)) -> isNePal(X),
                                isPal(mark(X)) -> isPal(X),
                              isPal(active(X)) -> isPal(X)}
             SPSC:
              Simple Projection:
               pi(and#) = 0
              Strict:
               {and#(X1, active(X2)) -> and#(X1, X2)}
              EDG:
               {(and#(X1, active(X2)) -> and#(X1, X2), and#(X1, active(X2)) -> and#(X1, X2))}
               SCCS:
                Scc:
                 {and#(X1, active(X2)) -> and#(X1, X2)}
                SCC:
                 Strict:
                  {and#(X1, active(X2)) -> and#(X1, X2)}
                 Weak:
                 {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                       mark(nil()) -> active(nil()),
                                 mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                        mark(tt()) -> active(tt()),
                                 mark(isNeList(X)) -> active(isNeList(X)),
                                   mark(isList(X)) -> active(isList(X)),
                                    mark(isQid(X)) -> active(isQid(X)),
                                  mark(isNePal(X)) -> active(isNePal(X)),
                                    mark(isPal(X)) -> active(isPal(X)),
                                         mark(a()) -> active(a()),
                                         mark(e()) -> active(e()),
                                         mark(i()) -> active(i()),
                                         mark(o()) -> active(o()),
                                         mark(u()) -> active(u()),
                                  __(X1, mark(X2)) -> __(X1, X2),
                                __(X1, active(X2)) -> __(X1, X2),
                                  __(mark(X1), X2) -> __(X1, X2),
                                __(active(X1), X2) -> __(X1, X2),
                              active(__(X, nil())) -> mark(X),
                           active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                              active(__(nil(), X)) -> mark(X),
                              active(and(tt(), X)) -> mark(X),
                               active(isNeList(V)) -> mark(isQid(V)),
                      active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                      active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                 active(isList(V)) -> mark(isNeList(V)),
                        active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                             active(isList(nil())) -> mark(tt()),
                                active(isQid(a())) -> mark(tt()),
                                active(isQid(e())) -> mark(tt()),
                                active(isQid(i())) -> mark(tt()),
                                active(isQid(o())) -> mark(tt()),
                                active(isQid(u())) -> mark(tt()),
                                active(isNePal(V)) -> mark(isQid(V)),
                  active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                  active(isPal(V)) -> mark(isNePal(V)),
                              active(isPal(nil())) -> mark(tt()),
                                 and(X1, mark(X2)) -> and(X1, X2),
                               and(X1, active(X2)) -> and(X1, X2),
                                 and(mark(X1), X2) -> and(X1, X2),
                               and(active(X1), X2) -> and(X1, X2),
                                 isNeList(mark(X)) -> isNeList(X),
                               isNeList(active(X)) -> isNeList(X),
                                   isList(mark(X)) -> isList(X),
                                 isList(active(X)) -> isList(X),
                                    isQid(mark(X)) -> isQid(X),
                                  isQid(active(X)) -> isQid(X),
                                  isNePal(mark(X)) -> isNePal(X),
                                isNePal(active(X)) -> isNePal(X),
                                    isPal(mark(X)) -> isPal(X),
                                  isPal(active(X)) -> isPal(X)}
                 SPSC:
                  Simple Projection:
                   pi(and#) = 1
                  Strict:
                   {}
                  Qed
    SCC:
     Strict:
      {  __#(X1, mark(X2)) -> __#(X1, X2),
       __#(X1, active(X2)) -> __#(X1, X2),
         __#(mark(X1), X2) -> __#(X1, X2),
       __#(active(X1), X2) -> __#(X1, X2)}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     SPSC:
      Simple Projection:
       pi(__#) = 0
      Strict:
       {  __#(X1, mark(X2)) -> __#(X1, X2),
        __#(X1, active(X2)) -> __#(X1, X2),
          __#(mark(X1), X2) -> __#(X1, X2)}
      EDG:
       {(__#(X1, active(X2)) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))
        (__#(X1, active(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
        (__#(X1, active(X2)) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
        (__#(mark(X1), X2) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
        (__#(mark(X1), X2) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
        (__#(mark(X1), X2) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))
        (__#(X1, mark(X2)) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
        (__#(X1, mark(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
        (__#(X1, mark(X2)) -> __#(X1, X2), __#(mark(X1), X2) -> __#(X1, X2))}
       SCCS:
        Scc:
         {  __#(X1, mark(X2)) -> __#(X1, X2),
          __#(X1, active(X2)) -> __#(X1, X2),
            __#(mark(X1), X2) -> __#(X1, X2)}
        SCC:
         Strict:
          {  __#(X1, mark(X2)) -> __#(X1, X2),
           __#(X1, active(X2)) -> __#(X1, X2),
             __#(mark(X1), X2) -> __#(X1, X2)}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         SPSC:
          Simple Projection:
           pi(__#) = 0
          Strict:
           {  __#(X1, mark(X2)) -> __#(X1, X2),
            __#(X1, active(X2)) -> __#(X1, X2)}
          EDG:
           {(__#(X1, active(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))
            (__#(X1, active(X2)) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
            (__#(X1, mark(X2)) -> __#(X1, X2), __#(X1, mark(X2)) -> __#(X1, X2))
            (__#(X1, mark(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))}
           SCCS:
            Scc:
             {  __#(X1, mark(X2)) -> __#(X1, X2),
              __#(X1, active(X2)) -> __#(X1, X2)}
            SCC:
             Strict:
              {  __#(X1, mark(X2)) -> __#(X1, X2),
               __#(X1, active(X2)) -> __#(X1, X2)}
             Weak:
             {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                   mark(nil()) -> active(nil()),
                             mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                    mark(tt()) -> active(tt()),
                             mark(isNeList(X)) -> active(isNeList(X)),
                               mark(isList(X)) -> active(isList(X)),
                                mark(isQid(X)) -> active(isQid(X)),
                              mark(isNePal(X)) -> active(isNePal(X)),
                                mark(isPal(X)) -> active(isPal(X)),
                                     mark(a()) -> active(a()),
                                     mark(e()) -> active(e()),
                                     mark(i()) -> active(i()),
                                     mark(o()) -> active(o()),
                                     mark(u()) -> active(u()),
                              __(X1, mark(X2)) -> __(X1, X2),
                            __(X1, active(X2)) -> __(X1, X2),
                              __(mark(X1), X2) -> __(X1, X2),
                            __(active(X1), X2) -> __(X1, X2),
                          active(__(X, nil())) -> mark(X),
                       active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                          active(__(nil(), X)) -> mark(X),
                          active(and(tt(), X)) -> mark(X),
                           active(isNeList(V)) -> mark(isQid(V)),
                  active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                  active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                             active(isList(V)) -> mark(isNeList(V)),
                    active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                         active(isList(nil())) -> mark(tt()),
                            active(isQid(a())) -> mark(tt()),
                            active(isQid(e())) -> mark(tt()),
                            active(isQid(i())) -> mark(tt()),
                            active(isQid(o())) -> mark(tt()),
                            active(isQid(u())) -> mark(tt()),
                            active(isNePal(V)) -> mark(isQid(V)),
              active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                              active(isPal(V)) -> mark(isNePal(V)),
                          active(isPal(nil())) -> mark(tt()),
                             and(X1, mark(X2)) -> and(X1, X2),
                           and(X1, active(X2)) -> and(X1, X2),
                             and(mark(X1), X2) -> and(X1, X2),
                           and(active(X1), X2) -> and(X1, X2),
                             isNeList(mark(X)) -> isNeList(X),
                           isNeList(active(X)) -> isNeList(X),
                               isList(mark(X)) -> isList(X),
                             isList(active(X)) -> isList(X),
                                isQid(mark(X)) -> isQid(X),
                              isQid(active(X)) -> isQid(X),
                              isNePal(mark(X)) -> isNePal(X),
                            isNePal(active(X)) -> isNePal(X),
                                isPal(mark(X)) -> isPal(X),
                              isPal(active(X)) -> isPal(X)}
             SPSC:
              Simple Projection:
               pi(__#) = 1
              Strict:
               {__#(X1, active(X2)) -> __#(X1, X2)}
              EDG:
               {(__#(X1, active(X2)) -> __#(X1, X2), __#(X1, active(X2)) -> __#(X1, X2))}
               SCCS:
                Scc:
                 {__#(X1, active(X2)) -> __#(X1, X2)}
                SCC:
                 Strict:
                  {__#(X1, active(X2)) -> __#(X1, X2)}
                 Weak:
                 {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                       mark(nil()) -> active(nil()),
                                 mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                        mark(tt()) -> active(tt()),
                                 mark(isNeList(X)) -> active(isNeList(X)),
                                   mark(isList(X)) -> active(isList(X)),
                                    mark(isQid(X)) -> active(isQid(X)),
                                  mark(isNePal(X)) -> active(isNePal(X)),
                                    mark(isPal(X)) -> active(isPal(X)),
                                         mark(a()) -> active(a()),
                                         mark(e()) -> active(e()),
                                         mark(i()) -> active(i()),
                                         mark(o()) -> active(o()),
                                         mark(u()) -> active(u()),
                                  __(X1, mark(X2)) -> __(X1, X2),
                                __(X1, active(X2)) -> __(X1, X2),
                                  __(mark(X1), X2) -> __(X1, X2),
                                __(active(X1), X2) -> __(X1, X2),
                              active(__(X, nil())) -> mark(X),
                           active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                              active(__(nil(), X)) -> mark(X),
                              active(and(tt(), X)) -> mark(X),
                               active(isNeList(V)) -> mark(isQid(V)),
                      active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                      active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                 active(isList(V)) -> mark(isNeList(V)),
                        active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                             active(isList(nil())) -> mark(tt()),
                                active(isQid(a())) -> mark(tt()),
                                active(isQid(e())) -> mark(tt()),
                                active(isQid(i())) -> mark(tt()),
                                active(isQid(o())) -> mark(tt()),
                                active(isQid(u())) -> mark(tt()),
                                active(isNePal(V)) -> mark(isQid(V)),
                  active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                  active(isPal(V)) -> mark(isNePal(V)),
                              active(isPal(nil())) -> mark(tt()),
                                 and(X1, mark(X2)) -> and(X1, X2),
                               and(X1, active(X2)) -> and(X1, X2),
                                 and(mark(X1), X2) -> and(X1, X2),
                               and(active(X1), X2) -> and(X1, X2),
                                 isNeList(mark(X)) -> isNeList(X),
                               isNeList(active(X)) -> isNeList(X),
                                   isList(mark(X)) -> isList(X),
                                 isList(active(X)) -> isList(X),
                                    isQid(mark(X)) -> isQid(X),
                                  isQid(active(X)) -> isQid(X),
                                  isNePal(mark(X)) -> isNePal(X),
                                isNePal(active(X)) -> isNePal(X),
                                    isPal(mark(X)) -> isPal(X),
                                  isPal(active(X)) -> isPal(X)}
                 SPSC:
                  Simple Projection:
                   pi(__#) = 1
                  Strict:
                   {}
                  Qed
    SCC:
     Strict:
      {                mark#(__(X1, X2)) -> mark#(X1),
                       mark#(__(X1, X2)) -> mark#(X2),
                       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                      mark#(and(X1, X2)) -> mark#(X1),
                      mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                      mark#(isNeList(X)) -> active#(isNeList(X)),
                        mark#(isList(X)) -> active#(isList(X)),
                         mark#(isQid(X)) -> active#(isQid(X)),
                       mark#(isNePal(X)) -> active#(isNePal(X)),
                         mark#(isPal(X)) -> active#(isPal(X)),
                   active#(__(X, nil())) -> mark#(X),
                active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                   active#(__(nil(), X)) -> mark#(X),
                   active#(and(tt(), X)) -> mark#(X),
                    active#(isNeList(V)) -> mark#(isQid(V)),
           active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
           active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                      active#(isList(V)) -> mark#(isNeList(V)),
             active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                     active#(isNePal(V)) -> mark#(isQid(V)),
       active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                       active#(isPal(V)) -> mark#(isNePal(V))}
     Weak:
     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                           mark(nil()) -> active(nil()),
                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                            mark(tt()) -> active(tt()),
                     mark(isNeList(X)) -> active(isNeList(X)),
                       mark(isList(X)) -> active(isList(X)),
                        mark(isQid(X)) -> active(isQid(X)),
                      mark(isNePal(X)) -> active(isNePal(X)),
                        mark(isPal(X)) -> active(isPal(X)),
                             mark(a()) -> active(a()),
                             mark(e()) -> active(e()),
                             mark(i()) -> active(i()),
                             mark(o()) -> active(o()),
                             mark(u()) -> active(u()),
                      __(X1, mark(X2)) -> __(X1, X2),
                    __(X1, active(X2)) -> __(X1, X2),
                      __(mark(X1), X2) -> __(X1, X2),
                    __(active(X1), X2) -> __(X1, X2),
                  active(__(X, nil())) -> mark(X),
               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                  active(__(nil(), X)) -> mark(X),
                  active(and(tt(), X)) -> mark(X),
                   active(isNeList(V)) -> mark(isQid(V)),
          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                     active(isList(V)) -> mark(isNeList(V)),
            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                 active(isList(nil())) -> mark(tt()),
                    active(isQid(a())) -> mark(tt()),
                    active(isQid(e())) -> mark(tt()),
                    active(isQid(i())) -> mark(tt()),
                    active(isQid(o())) -> mark(tt()),
                    active(isQid(u())) -> mark(tt()),
                    active(isNePal(V)) -> mark(isQid(V)),
      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                      active(isPal(V)) -> mark(isNePal(V)),
                  active(isPal(nil())) -> mark(tt()),
                     and(X1, mark(X2)) -> and(X1, X2),
                   and(X1, active(X2)) -> and(X1, X2),
                     and(mark(X1), X2) -> and(X1, X2),
                   and(active(X1), X2) -> and(X1, X2),
                     isNeList(mark(X)) -> isNeList(X),
                   isNeList(active(X)) -> isNeList(X),
                       isList(mark(X)) -> isList(X),
                     isList(active(X)) -> isList(X),
                        isQid(mark(X)) -> isQid(X),
                      isQid(active(X)) -> isQid(X),
                      isNePal(mark(X)) -> isNePal(X),
                    isNePal(active(X)) -> isNePal(X),
                        isPal(mark(X)) -> isPal(X),
                      isPal(active(X)) -> isPal(X)}
     POLY:
      Argument Filtering:
       pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [], pi(nil) = [], pi(active#) = 0, pi(active) = [], pi(__) = [], pi(mark#) = [], pi(mark) = []
      Usable Rules:
       {}
      Interpretation:
       [mark#] = 1,
       [and] = 1,
       [__] = 1,
       [isPal] = 1,
       [isNePal] = 1,
       [isQid] = 0,
       [isList] = 1,
       [isNeList] = 1
      Strict:
       {                mark#(__(X1, X2)) -> mark#(X1),
                        mark#(__(X1, X2)) -> mark#(X2),
                        mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                       mark#(and(X1, X2)) -> mark#(X1),
                       mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                       mark#(isNeList(X)) -> active#(isNeList(X)),
                         mark#(isList(X)) -> active#(isList(X)),
                        mark#(isNePal(X)) -> active#(isNePal(X)),
                          mark#(isPal(X)) -> active#(isPal(X)),
                    active#(__(X, nil())) -> mark#(X),
                 active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                    active#(__(nil(), X)) -> mark#(X),
                    active#(and(tt(), X)) -> mark#(X),
                     active#(isNeList(V)) -> mark#(isQid(V)),
            active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
            active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                       active#(isList(V)) -> mark#(isNeList(V)),
              active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                      active#(isNePal(V)) -> mark#(isQid(V)),
        active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                        active#(isPal(V)) -> mark#(isNePal(V))}
      Weak:
       {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                             mark(nil()) -> active(nil()),
                       mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                              mark(tt()) -> active(tt()),
                       mark(isNeList(X)) -> active(isNeList(X)),
                         mark(isList(X)) -> active(isList(X)),
                          mark(isQid(X)) -> active(isQid(X)),
                        mark(isNePal(X)) -> active(isNePal(X)),
                          mark(isPal(X)) -> active(isPal(X)),
                               mark(a()) -> active(a()),
                               mark(e()) -> active(e()),
                               mark(i()) -> active(i()),
                               mark(o()) -> active(o()),
                               mark(u()) -> active(u()),
                        __(X1, mark(X2)) -> __(X1, X2),
                      __(X1, active(X2)) -> __(X1, X2),
                        __(mark(X1), X2) -> __(X1, X2),
                      __(active(X1), X2) -> __(X1, X2),
                    active(__(X, nil())) -> mark(X),
                 active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                    active(__(nil(), X)) -> mark(X),
                    active(and(tt(), X)) -> mark(X),
                     active(isNeList(V)) -> mark(isQid(V)),
            active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
            active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                       active(isList(V)) -> mark(isNeList(V)),
              active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                   active(isList(nil())) -> mark(tt()),
                      active(isQid(a())) -> mark(tt()),
                      active(isQid(e())) -> mark(tt()),
                      active(isQid(i())) -> mark(tt()),
                      active(isQid(o())) -> mark(tt()),
                      active(isQid(u())) -> mark(tt()),
                      active(isNePal(V)) -> mark(isQid(V)),
        active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                        active(isPal(V)) -> mark(isNePal(V)),
                    active(isPal(nil())) -> mark(tt()),
                       and(X1, mark(X2)) -> and(X1, X2),
                     and(X1, active(X2)) -> and(X1, X2),
                       and(mark(X1), X2) -> and(X1, X2),
                     and(active(X1), X2) -> and(X1, X2),
                       isNeList(mark(X)) -> isNeList(X),
                     isNeList(active(X)) -> isNeList(X),
                         isList(mark(X)) -> isList(X),
                       isList(active(X)) -> isList(X),
                          isQid(mark(X)) -> isQid(X),
                        isQid(active(X)) -> isQid(X),
                        isNePal(mark(X)) -> isNePal(X),
                      isNePal(active(X)) -> isNePal(X),
                          isPal(mark(X)) -> isPal(X),
                        isPal(active(X)) -> isPal(X)}
      EDG:
       {
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isList(X)) -> active#(isList(X)))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X2))
        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isList(X)) -> active#(isList(X)))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isList(X)) -> active#(isList(X)))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X1))
        (mark#(isList(X)) -> active#(isList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
        (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
        (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
        (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
        (mark#(isList(X)) -> active#(isList(X)), active#(isList(V)) -> mark#(isNeList(V)))
        (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
        (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
        (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
        (mark#(isList(X)) -> active#(isList(X)), active#(and(tt(), X)) -> mark#(X))
        (mark#(isList(X)) -> active#(isList(X)), active#(__(nil(), X)) -> mark#(X))
        (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
        (mark#(isList(X)) -> active#(isList(X)), active#(__(X, nil())) -> mark#(X))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> mark#(isNeList(V)))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(and(tt(), X)) -> mark#(X))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(__(nil(), X)) -> mark#(X))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
        (mark#(isPal(X)) -> active#(isPal(X)), active#(__(X, nil())) -> mark#(X))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(isPal(X)) -> active#(isPal(X)))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(isNePal(X)) -> active#(isNePal(X)))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(isList(X)) -> active#(isList(X)))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(isNeList(X)) -> active#(isNeList(X)))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> mark#(X1))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X2))
        (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X1))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
        (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
        (active#(__(nil(), X)) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(__(nil(), X)) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(__(nil(), X)) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
        (active#(__(nil(), X)) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(__(nil(), X)) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(__(nil(), X)) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
        (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
        (active#(__(nil(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
        (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
        (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
        (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
        (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(and(tt(), X)) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(and(tt(), X)) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
        (active#(and(tt(), X)) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(and(tt(), X)) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
        (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
        (active#(__(X, nil())) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(__(X, nil())) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
        (active#(__(X, nil())) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(__(X, nil())) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(__(X, nil())) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
        (active#(__(X, nil())) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(__(X, nil())) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
        (mark#(__(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isList(X)) -> active#(isList(X)))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isList(X)) -> active#(isList(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(X, nil())) -> mark#(X))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(nil(), X)) -> mark#(X))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(and(tt(), X)) -> mark#(X))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(X, nil())) -> mark#(X))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(nil(), X)) -> mark#(X))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(and(tt(), X)) -> mark#(X))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(X, nil())) -> mark#(X))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(nil(), X)) -> mark#(X))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(and(tt(), X)) -> mark#(X))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(X, nil())) -> mark#(X))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(nil(), X)) -> mark#(X))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(and(tt(), X)) -> mark#(X))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))
       }
       SCCS:
        Scc:
         {                mark#(__(X1, X2)) -> mark#(X1),
                          mark#(__(X1, X2)) -> mark#(X2),
                          mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                         mark#(and(X1, X2)) -> mark#(X1),
                         mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                         mark#(isNeList(X)) -> active#(isNeList(X)),
                           mark#(isList(X)) -> active#(isList(X)),
                          mark#(isNePal(X)) -> active#(isNePal(X)),
                            mark#(isPal(X)) -> active#(isPal(X)),
                      active#(__(X, nil())) -> mark#(X),
                   active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                      active#(__(nil(), X)) -> mark#(X),
                      active#(and(tt(), X)) -> mark#(X),
                       active#(isNeList(V)) -> mark#(isQid(V)),
              active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
              active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                         active#(isList(V)) -> mark#(isNeList(V)),
                active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                        active#(isNePal(V)) -> mark#(isQid(V)),
          active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                          active#(isPal(V)) -> mark#(isNePal(V))}
        SCC:
         Strict:
          {                mark#(__(X1, X2)) -> mark#(X1),
                           mark#(__(X1, X2)) -> mark#(X2),
                           mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                          mark#(and(X1, X2)) -> mark#(X1),
                          mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                          mark#(isNeList(X)) -> active#(isNeList(X)),
                            mark#(isList(X)) -> active#(isList(X)),
                           mark#(isNePal(X)) -> active#(isNePal(X)),
                             mark#(isPal(X)) -> active#(isPal(X)),
                       active#(__(X, nil())) -> mark#(X),
                    active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                       active#(__(nil(), X)) -> mark#(X),
                       active#(and(tt(), X)) -> mark#(X),
                        active#(isNeList(V)) -> mark#(isQid(V)),
               active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
               active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                          active#(isList(V)) -> mark#(isNeList(V)),
                 active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                         active#(isNePal(V)) -> mark#(isQid(V)),
           active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                           active#(isPal(V)) -> mark#(isNePal(V))}
         Weak:
         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                               mark(nil()) -> active(nil()),
                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                mark(tt()) -> active(tt()),
                         mark(isNeList(X)) -> active(isNeList(X)),
                           mark(isList(X)) -> active(isList(X)),
                            mark(isQid(X)) -> active(isQid(X)),
                          mark(isNePal(X)) -> active(isNePal(X)),
                            mark(isPal(X)) -> active(isPal(X)),
                                 mark(a()) -> active(a()),
                                 mark(e()) -> active(e()),
                                 mark(i()) -> active(i()),
                                 mark(o()) -> active(o()),
                                 mark(u()) -> active(u()),
                          __(X1, mark(X2)) -> __(X1, X2),
                        __(X1, active(X2)) -> __(X1, X2),
                          __(mark(X1), X2) -> __(X1, X2),
                        __(active(X1), X2) -> __(X1, X2),
                      active(__(X, nil())) -> mark(X),
                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                      active(__(nil(), X)) -> mark(X),
                      active(and(tt(), X)) -> mark(X),
                       active(isNeList(V)) -> mark(isQid(V)),
              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                         active(isList(V)) -> mark(isNeList(V)),
                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                     active(isList(nil())) -> mark(tt()),
                        active(isQid(a())) -> mark(tt()),
                        active(isQid(e())) -> mark(tt()),
                        active(isQid(i())) -> mark(tt()),
                        active(isQid(o())) -> mark(tt()),
                        active(isQid(u())) -> mark(tt()),
                        active(isNePal(V)) -> mark(isQid(V)),
          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                          active(isPal(V)) -> mark(isNePal(V)),
                      active(isPal(nil())) -> mark(tt()),
                         and(X1, mark(X2)) -> and(X1, X2),
                       and(X1, active(X2)) -> and(X1, X2),
                         and(mark(X1), X2) -> and(X1, X2),
                       and(active(X1), X2) -> and(X1, X2),
                         isNeList(mark(X)) -> isNeList(X),
                       isNeList(active(X)) -> isNeList(X),
                           isList(mark(X)) -> isList(X),
                         isList(active(X)) -> isList(X),
                            isQid(mark(X)) -> isQid(X),
                          isQid(active(X)) -> isQid(X),
                          isNePal(mark(X)) -> isNePal(X),
                        isNePal(active(X)) -> isNePal(X),
                            isPal(mark(X)) -> isPal(X),
                          isPal(active(X)) -> isPal(X)}
         POLY:
          Argument Filtering:
           pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [0,1], pi(nil) = [], pi(active#) = 0, pi(active) = 0, pi(__) = [0,1], pi(mark#) = 0, pi(mark) = 0
          Usable Rules:
           {}
          Interpretation:
           [and](x0, x1) = x0 + x1,
           [__](x0, x1) = x0 + x1,
           [isPal] = 0,
           [isNePal] = 0,
           [isQid] = 0,
           [isList] = 0,
           [isNeList] = 0,
           [tt] = 0,
           [nil] = 1
          Strict:
           {                mark#(__(X1, X2)) -> mark#(X1),
                            mark#(__(X1, X2)) -> mark#(X2),
                            mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                           mark#(and(X1, X2)) -> mark#(X1),
                           mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                           mark#(isNeList(X)) -> active#(isNeList(X)),
                             mark#(isList(X)) -> active#(isList(X)),
                            mark#(isNePal(X)) -> active#(isNePal(X)),
                              mark#(isPal(X)) -> active#(isPal(X)),
                     active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                        active#(and(tt(), X)) -> mark#(X),
                         active#(isNeList(V)) -> mark#(isQid(V)),
                active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
                active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                           active#(isList(V)) -> mark#(isNeList(V)),
                  active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                          active#(isNePal(V)) -> mark#(isQid(V)),
            active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                            active#(isPal(V)) -> mark#(isNePal(V))}
          Weak:
           {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                 mark(nil()) -> active(nil()),
                           mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                  mark(tt()) -> active(tt()),
                           mark(isNeList(X)) -> active(isNeList(X)),
                             mark(isList(X)) -> active(isList(X)),
                              mark(isQid(X)) -> active(isQid(X)),
                            mark(isNePal(X)) -> active(isNePal(X)),
                              mark(isPal(X)) -> active(isPal(X)),
                                   mark(a()) -> active(a()),
                                   mark(e()) -> active(e()),
                                   mark(i()) -> active(i()),
                                   mark(o()) -> active(o()),
                                   mark(u()) -> active(u()),
                            __(X1, mark(X2)) -> __(X1, X2),
                          __(X1, active(X2)) -> __(X1, X2),
                            __(mark(X1), X2) -> __(X1, X2),
                          __(active(X1), X2) -> __(X1, X2),
                        active(__(X, nil())) -> mark(X),
                     active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                        active(__(nil(), X)) -> mark(X),
                        active(and(tt(), X)) -> mark(X),
                         active(isNeList(V)) -> mark(isQid(V)),
                active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                           active(isList(V)) -> mark(isNeList(V)),
                  active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                       active(isList(nil())) -> mark(tt()),
                          active(isQid(a())) -> mark(tt()),
                          active(isQid(e())) -> mark(tt()),
                          active(isQid(i())) -> mark(tt()),
                          active(isQid(o())) -> mark(tt()),
                          active(isQid(u())) -> mark(tt()),
                          active(isNePal(V)) -> mark(isQid(V)),
            active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                            active(isPal(V)) -> mark(isNePal(V)),
                        active(isPal(nil())) -> mark(tt()),
                           and(X1, mark(X2)) -> and(X1, X2),
                         and(X1, active(X2)) -> and(X1, X2),
                           and(mark(X1), X2) -> and(X1, X2),
                         and(active(X1), X2) -> and(X1, X2),
                           isNeList(mark(X)) -> isNeList(X),
                         isNeList(active(X)) -> isNeList(X),
                             isList(mark(X)) -> isList(X),
                           isList(active(X)) -> isList(X),
                              isQid(mark(X)) -> isQid(X),
                            isQid(active(X)) -> isQid(X),
                            isNePal(mark(X)) -> isNePal(X),
                          isNePal(active(X)) -> isNePal(X),
                              isPal(mark(X)) -> isPal(X),
                            isPal(active(X)) -> isPal(X)}
          EDG:
           {
            (mark#(__(X1, X2)) -> mark#(X2), mark#(isPal(X)) -> active#(isPal(X)))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(isNePal(X)) -> active#(isNePal(X)))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(isList(X)) -> active#(isList(X)))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(isNeList(X)) -> active#(isNeList(X)))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> mark#(X1))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X2))
            (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(isList(X)) -> active#(isList(X)))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isList(X)) -> active#(isList(X)))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X1))
            (mark#(isList(X)) -> active#(isList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
            (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
            (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
            (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
            (mark#(isList(X)) -> active#(isList(X)), active#(isList(V)) -> mark#(isNeList(V)))
            (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
            (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
            (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
            (mark#(isList(X)) -> active#(isList(X)), active#(and(tt(), X)) -> mark#(X))
            (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> mark#(isNeList(V)))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(and(tt(), X)) -> mark#(X))
            (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
            (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isList(X)) -> active#(isList(X)))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X2))
            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X1))
            (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X1))
            (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> mark#(X2))
            (active#(and(tt(), X)) -> mark#(X), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> mark#(X1))
            (active#(and(tt(), X)) -> mark#(X), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(and(tt(), X)) -> mark#(X), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(and(tt(), X)) -> mark#(X), mark#(isList(X)) -> active#(isList(X)))
            (active#(and(tt(), X)) -> mark#(X), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(and(tt(), X)) -> mark#(X), mark#(isPal(X)) -> active#(isPal(X)))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
            (mark#(and(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isList(X)) -> active#(isList(X)))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isList(X)) -> active#(isList(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(and(tt(), X)) -> mark#(X))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(and(tt(), X)) -> mark#(X))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(and(tt(), X)) -> mark#(X))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(and(tt(), X)) -> mark#(X))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))
           }
           SCCS:
            Scc:
             {                mark#(__(X1, X2)) -> mark#(X1),
                              mark#(__(X1, X2)) -> mark#(X2),
                              mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                             mark#(and(X1, X2)) -> mark#(X1),
                             mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                             mark#(isNeList(X)) -> active#(isNeList(X)),
                               mark#(isList(X)) -> active#(isList(X)),
                              mark#(isNePal(X)) -> active#(isNePal(X)),
                                mark#(isPal(X)) -> active#(isPal(X)),
                       active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                          active#(and(tt(), X)) -> mark#(X),
                           active#(isNeList(V)) -> mark#(isQid(V)),
                  active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
                  active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                             active#(isList(V)) -> mark#(isNeList(V)),
                    active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                            active#(isNePal(V)) -> mark#(isQid(V)),
              active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                              active#(isPal(V)) -> mark#(isNePal(V))}
            SCC:
             Strict:
              {                mark#(__(X1, X2)) -> mark#(X1),
                               mark#(__(X1, X2)) -> mark#(X2),
                               mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                              mark#(and(X1, X2)) -> mark#(X1),
                              mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                              mark#(isNeList(X)) -> active#(isNeList(X)),
                                mark#(isList(X)) -> active#(isList(X)),
                               mark#(isNePal(X)) -> active#(isNePal(X)),
                                 mark#(isPal(X)) -> active#(isPal(X)),
                        active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                           active#(and(tt(), X)) -> mark#(X),
                            active#(isNeList(V)) -> mark#(isQid(V)),
                   active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
                   active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                              active#(isList(V)) -> mark#(isNeList(V)),
                     active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                             active#(isNePal(V)) -> mark#(isQid(V)),
               active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                               active#(isPal(V)) -> mark#(isNePal(V))}
             Weak:
             {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                   mark(nil()) -> active(nil()),
                             mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                    mark(tt()) -> active(tt()),
                             mark(isNeList(X)) -> active(isNeList(X)),
                               mark(isList(X)) -> active(isList(X)),
                                mark(isQid(X)) -> active(isQid(X)),
                              mark(isNePal(X)) -> active(isNePal(X)),
                                mark(isPal(X)) -> active(isPal(X)),
                                     mark(a()) -> active(a()),
                                     mark(e()) -> active(e()),
                                     mark(i()) -> active(i()),
                                     mark(o()) -> active(o()),
                                     mark(u()) -> active(u()),
                              __(X1, mark(X2)) -> __(X1, X2),
                            __(X1, active(X2)) -> __(X1, X2),
                              __(mark(X1), X2) -> __(X1, X2),
                            __(active(X1), X2) -> __(X1, X2),
                          active(__(X, nil())) -> mark(X),
                       active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                          active(__(nil(), X)) -> mark(X),
                          active(and(tt(), X)) -> mark(X),
                           active(isNeList(V)) -> mark(isQid(V)),
                  active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                  active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                             active(isList(V)) -> mark(isNeList(V)),
                    active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                         active(isList(nil())) -> mark(tt()),
                            active(isQid(a())) -> mark(tt()),
                            active(isQid(e())) -> mark(tt()),
                            active(isQid(i())) -> mark(tt()),
                            active(isQid(o())) -> mark(tt()),
                            active(isQid(u())) -> mark(tt()),
                            active(isNePal(V)) -> mark(isQid(V)),
              active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                              active(isPal(V)) -> mark(isNePal(V)),
                          active(isPal(nil())) -> mark(tt()),
                             and(X1, mark(X2)) -> and(X1, X2),
                           and(X1, active(X2)) -> and(X1, X2),
                             and(mark(X1), X2) -> and(X1, X2),
                           and(active(X1), X2) -> and(X1, X2),
                             isNeList(mark(X)) -> isNeList(X),
                           isNeList(active(X)) -> isNeList(X),
                               isList(mark(X)) -> isList(X),
                             isList(active(X)) -> isList(X),
                                isQid(mark(X)) -> isQid(X),
                              isQid(active(X)) -> isQid(X),
                              isNePal(mark(X)) -> isNePal(X),
                            isNePal(active(X)) -> isNePal(X),
                                isPal(mark(X)) -> isPal(X),
                              isPal(active(X)) -> isPal(X)}
             POLY:
              Argument Filtering:
               pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = 0, pi(isNePal) = 0, pi(isQid) = 0, pi(isList) = 0, pi(isNeList) = 0, pi(tt) = [], pi(and) = [0,1], pi(nil) = [], pi(active#) = 0, pi(active) = 0, pi(__) = [0,1], pi(mark#) = 0, pi(mark) = 0
              Usable Rules:
               {}
              Interpretation:
               [and](x0, x1) = x0 + x1,
               [__](x0, x1) = x0 + x1,
               [tt] = 1
              Strict:
               {                mark#(__(X1, X2)) -> mark#(X1),
                                mark#(__(X1, X2)) -> mark#(X2),
                                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                               mark#(and(X1, X2)) -> mark#(X1),
                               mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                               mark#(isNeList(X)) -> active#(isNeList(X)),
                                 mark#(isList(X)) -> active#(isList(X)),
                                mark#(isNePal(X)) -> active#(isNePal(X)),
                                  mark#(isPal(X)) -> active#(isPal(X)),
                         active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                             active#(isNeList(V)) -> mark#(isQid(V)),
                    active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
                    active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                               active#(isList(V)) -> mark#(isNeList(V)),
                      active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                              active#(isNePal(V)) -> mark#(isQid(V)),
                active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                active#(isPal(V)) -> mark#(isNePal(V))}
              Weak:
               {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                     mark(nil()) -> active(nil()),
                               mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                      mark(tt()) -> active(tt()),
                               mark(isNeList(X)) -> active(isNeList(X)),
                                 mark(isList(X)) -> active(isList(X)),
                                  mark(isQid(X)) -> active(isQid(X)),
                                mark(isNePal(X)) -> active(isNePal(X)),
                                  mark(isPal(X)) -> active(isPal(X)),
                                       mark(a()) -> active(a()),
                                       mark(e()) -> active(e()),
                                       mark(i()) -> active(i()),
                                       mark(o()) -> active(o()),
                                       mark(u()) -> active(u()),
                                __(X1, mark(X2)) -> __(X1, X2),
                              __(X1, active(X2)) -> __(X1, X2),
                                __(mark(X1), X2) -> __(X1, X2),
                              __(active(X1), X2) -> __(X1, X2),
                            active(__(X, nil())) -> mark(X),
                         active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                            active(__(nil(), X)) -> mark(X),
                            active(and(tt(), X)) -> mark(X),
                             active(isNeList(V)) -> mark(isQid(V)),
                    active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                    active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                               active(isList(V)) -> mark(isNeList(V)),
                      active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                           active(isList(nil())) -> mark(tt()),
                              active(isQid(a())) -> mark(tt()),
                              active(isQid(e())) -> mark(tt()),
                              active(isQid(i())) -> mark(tt()),
                              active(isQid(o())) -> mark(tt()),
                              active(isQid(u())) -> mark(tt()),
                              active(isNePal(V)) -> mark(isQid(V)),
                active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                active(isPal(V)) -> mark(isNePal(V)),
                            active(isPal(nil())) -> mark(tt()),
                               and(X1, mark(X2)) -> and(X1, X2),
                             and(X1, active(X2)) -> and(X1, X2),
                               and(mark(X1), X2) -> and(X1, X2),
                             and(active(X1), X2) -> and(X1, X2),
                               isNeList(mark(X)) -> isNeList(X),
                             isNeList(active(X)) -> isNeList(X),
                                 isList(mark(X)) -> isList(X),
                               isList(active(X)) -> isList(X),
                                  isQid(mark(X)) -> isQid(X),
                                isQid(active(X)) -> isQid(X),
                                isNePal(mark(X)) -> isNePal(X),
                              isNePal(active(X)) -> isNePal(X),
                                  isPal(mark(X)) -> isPal(X),
                                isPal(active(X)) -> isPal(X)}
              EDG:
               {
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isList(X)) -> active#(isList(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isList(X)) -> active#(isList(X)))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> mark#(X1))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
                (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(isList(X)) -> active#(isList(X)))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isList(X)) -> active#(isList(X)))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> mark#(X1))
                (mark#(isList(X)) -> active#(isList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                (mark#(isList(X)) -> active#(isList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
                (mark#(isList(X)) -> active#(isList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
                (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
                (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X1))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> mark#(X2))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isList(X)) -> active#(isList(X)))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isPal(X)) -> active#(isPal(X)))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X1))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> mark#(X2))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                (mark#(__(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X1))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> mark#(X2))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> mark#(X1))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNeList(X)) -> active#(isNeList(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isList(X)) -> active#(isList(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isNePal(X)) -> active#(isNePal(X)))
                (active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))), mark#(isPal(X)) -> active#(isPal(X)))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X1))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> mark#(X2))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> mark#(X1))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(isNeList(X)) -> active#(isNeList(X)))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(isList(X)) -> active#(isList(X)))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(isNePal(X)) -> active#(isNePal(X)))
                (mark#(__(X1, X2)) -> mark#(X2), mark#(isPal(X)) -> active#(isPal(X)))
               }
               SCCS:
                Scc:
                 {                mark#(__(X1, X2)) -> mark#(X1),
                                  mark#(__(X1, X2)) -> mark#(X2),
                                  mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                 mark#(and(X1, X2)) -> mark#(X1),
                                 mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                 mark#(isNeList(X)) -> active#(isNeList(X)),
                                   mark#(isList(X)) -> active#(isList(X)),
                                  mark#(isNePal(X)) -> active#(isNePal(X)),
                                    mark#(isPal(X)) -> active#(isPal(X)),
                           active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                               active#(isNeList(V)) -> mark#(isQid(V)),
                      active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
                      active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                                 active#(isList(V)) -> mark#(isNeList(V)),
                        active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                                active#(isNePal(V)) -> mark#(isQid(V)),
                  active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                  active#(isPal(V)) -> mark#(isNePal(V))}
                SCC:
                 Strict:
                  {                mark#(__(X1, X2)) -> mark#(X1),
                                   mark#(__(X1, X2)) -> mark#(X2),
                                   mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                  mark#(and(X1, X2)) -> mark#(X1),
                                  mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                  mark#(isNeList(X)) -> active#(isNeList(X)),
                                    mark#(isList(X)) -> active#(isList(X)),
                                   mark#(isNePal(X)) -> active#(isNePal(X)),
                                     mark#(isPal(X)) -> active#(isPal(X)),
                            active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                active#(isNeList(V)) -> mark#(isQid(V)),
                       active#(isNeList(__(V1, V2))) -> mark#(and(isNeList(V1), isList(V2))),
                       active#(isNeList(__(V1, V2))) -> mark#(and(isList(V1), isNeList(V2))),
                                  active#(isList(V)) -> mark#(isNeList(V)),
                         active#(isList(__(V1, V2))) -> mark#(and(isList(V1), isList(V2))),
                                 active#(isNePal(V)) -> mark#(isQid(V)),
                   active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                   active#(isPal(V)) -> mark#(isNePal(V))}
                 Weak:
                 {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                       mark(nil()) -> active(nil()),
                                 mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                        mark(tt()) -> active(tt()),
                                 mark(isNeList(X)) -> active(isNeList(X)),
                                   mark(isList(X)) -> active(isList(X)),
                                    mark(isQid(X)) -> active(isQid(X)),
                                  mark(isNePal(X)) -> active(isNePal(X)),
                                    mark(isPal(X)) -> active(isPal(X)),
                                         mark(a()) -> active(a()),
                                         mark(e()) -> active(e()),
                                         mark(i()) -> active(i()),
                                         mark(o()) -> active(o()),
                                         mark(u()) -> active(u()),
                                  __(X1, mark(X2)) -> __(X1, X2),
                                __(X1, active(X2)) -> __(X1, X2),
                                  __(mark(X1), X2) -> __(X1, X2),
                                __(active(X1), X2) -> __(X1, X2),
                              active(__(X, nil())) -> mark(X),
                           active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                              active(__(nil(), X)) -> mark(X),
                              active(and(tt(), X)) -> mark(X),
                               active(isNeList(V)) -> mark(isQid(V)),
                      active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                      active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                 active(isList(V)) -> mark(isNeList(V)),
                        active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                             active(isList(nil())) -> mark(tt()),
                                active(isQid(a())) -> mark(tt()),
                                active(isQid(e())) -> mark(tt()),
                                active(isQid(i())) -> mark(tt()),
                                active(isQid(o())) -> mark(tt()),
                                active(isQid(u())) -> mark(tt()),
                                active(isNePal(V)) -> mark(isQid(V)),
                  active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                  active(isPal(V)) -> mark(isNePal(V)),
                              active(isPal(nil())) -> mark(tt()),
                                 and(X1, mark(X2)) -> and(X1, X2),
                               and(X1, active(X2)) -> and(X1, X2),
                                 and(mark(X1), X2) -> and(X1, X2),
                               and(active(X1), X2) -> and(X1, X2),
                                 isNeList(mark(X)) -> isNeList(X),
                               isNeList(active(X)) -> isNeList(X),
                                   isList(mark(X)) -> isList(X),
                                 isList(active(X)) -> isList(X),
                                    isQid(mark(X)) -> isQid(X),
                                  isQid(active(X)) -> isQid(X),
                                  isNePal(mark(X)) -> isNePal(X),
                                isNePal(active(X)) -> isNePal(X),
                                    isPal(mark(X)) -> isPal(X),
                                  isPal(active(X)) -> isPal(X)}
                 POLY:
                  Argument Filtering:
                   pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = 0, pi(isNeList) = 0, pi(tt) = [], pi(and) = [0,1], pi(nil) = [], pi(active#) = 0, pi(active) = 0, pi(__) = [0,1], pi(mark#) = 0, pi(mark) = 0
                  Usable Rules:
                   {}
                  Interpretation:
                   [and](x0, x1) = x0 + x1,
                   [__](x0, x1) = x0 + x1 + 1,
                   [isPal] = 0,
                   [isNePal] = 0,
                   [isQid] = 0
                  Strict:
                   {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                   mark#(and(X1, X2)) -> mark#(X1),
                                   mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                   mark#(isNeList(X)) -> active#(isNeList(X)),
                                     mark#(isList(X)) -> active#(isList(X)),
                                    mark#(isNePal(X)) -> active#(isNePal(X)),
                                      mark#(isPal(X)) -> active#(isPal(X)),
                             active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                 active#(isNeList(V)) -> mark#(isQid(V)),
                                   active#(isList(V)) -> mark#(isNeList(V)),
                                  active#(isNePal(V)) -> mark#(isQid(V)),
                    active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                    active#(isPal(V)) -> mark#(isNePal(V))}
                  Weak:
                   {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                         mark(nil()) -> active(nil()),
                                   mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                          mark(tt()) -> active(tt()),
                                   mark(isNeList(X)) -> active(isNeList(X)),
                                     mark(isList(X)) -> active(isList(X)),
                                      mark(isQid(X)) -> active(isQid(X)),
                                    mark(isNePal(X)) -> active(isNePal(X)),
                                      mark(isPal(X)) -> active(isPal(X)),
                                           mark(a()) -> active(a()),
                                           mark(e()) -> active(e()),
                                           mark(i()) -> active(i()),
                                           mark(o()) -> active(o()),
                                           mark(u()) -> active(u()),
                                    __(X1, mark(X2)) -> __(X1, X2),
                                  __(X1, active(X2)) -> __(X1, X2),
                                    __(mark(X1), X2) -> __(X1, X2),
                                  __(active(X1), X2) -> __(X1, X2),
                                active(__(X, nil())) -> mark(X),
                             active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                active(__(nil(), X)) -> mark(X),
                                active(and(tt(), X)) -> mark(X),
                                 active(isNeList(V)) -> mark(isQid(V)),
                        active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                        active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                   active(isList(V)) -> mark(isNeList(V)),
                          active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                               active(isList(nil())) -> mark(tt()),
                                  active(isQid(a())) -> mark(tt()),
                                  active(isQid(e())) -> mark(tt()),
                                  active(isQid(i())) -> mark(tt()),
                                  active(isQid(o())) -> mark(tt()),
                                  active(isQid(u())) -> mark(tt()),
                                  active(isNePal(V)) -> mark(isQid(V)),
                    active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                    active(isPal(V)) -> mark(isNePal(V)),
                                active(isPal(nil())) -> mark(tt()),
                                   and(X1, mark(X2)) -> and(X1, X2),
                                 and(X1, active(X2)) -> and(X1, X2),
                                   and(mark(X1), X2) -> and(X1, X2),
                                 and(active(X1), X2) -> and(X1, X2),
                                   isNeList(mark(X)) -> isNeList(X),
                                 isNeList(active(X)) -> isNeList(X),
                                     isList(mark(X)) -> isList(X),
                                   isList(active(X)) -> isList(X),
                                      isQid(mark(X)) -> isQid(X),
                                    isQid(active(X)) -> isQid(X),
                                    isNePal(mark(X)) -> isNePal(X),
                                  isNePal(active(X)) -> isNePal(X),
                                      isPal(mark(X)) -> isPal(X),
                                    isPal(active(X)) -> isPal(X)}
                  EDG:
                   {(mark#(and(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
                    (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (mark#(and(X1, X2)) -> mark#(X1), mark#(isList(X)) -> active#(isList(X)))
                    (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isList(X)) -> active#(isList(X)))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                    (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                    (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                    (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                    (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                    (mark#(isList(X)) -> active#(isList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                    (mark#(isList(X)) -> active#(isList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                    (mark#(isList(X)) -> active#(isList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                    (mark#(isList(X)) -> active#(isList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                    (mark#(isList(X)) -> active#(isList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isList(X)) -> active#(isList(X)))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isPal(X)) -> active#(isPal(X)))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isList(X)) -> active#(isList(X)))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (active#(isList(V)) -> mark#(isNeList(V)), mark#(isPal(X)) -> active#(isPal(X)))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isList(X)) -> active#(isList(X)))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isPal(X)) -> active#(isPal(X)))
                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isList(X)) -> active#(isList(X)))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isPal(X)) -> active#(isPal(X)))}
                   SCCS:
                    Scc:
                     {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                     mark#(and(X1, X2)) -> mark#(X1),
                                     mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                     mark#(isNeList(X)) -> active#(isNeList(X)),
                                       mark#(isList(X)) -> active#(isList(X)),
                                      mark#(isNePal(X)) -> active#(isNePal(X)),
                                        mark#(isPal(X)) -> active#(isPal(X)),
                               active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                   active#(isNeList(V)) -> mark#(isQid(V)),
                                     active#(isList(V)) -> mark#(isNeList(V)),
                                    active#(isNePal(V)) -> mark#(isQid(V)),
                      active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                      active#(isPal(V)) -> mark#(isNePal(V))}
                    SCC:
                     Strict:
                      {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                      mark#(and(X1, X2)) -> mark#(X1),
                                      mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                      mark#(isNeList(X)) -> active#(isNeList(X)),
                                        mark#(isList(X)) -> active#(isList(X)),
                                       mark#(isNePal(X)) -> active#(isNePal(X)),
                                         mark#(isPal(X)) -> active#(isPal(X)),
                                active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                    active#(isNeList(V)) -> mark#(isQid(V)),
                                      active#(isList(V)) -> mark#(isNeList(V)),
                                     active#(isNePal(V)) -> mark#(isQid(V)),
                       active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                       active#(isPal(V)) -> mark#(isNePal(V))}
                     Weak:
                     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                           mark(nil()) -> active(nil()),
                                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                            mark(tt()) -> active(tt()),
                                     mark(isNeList(X)) -> active(isNeList(X)),
                                       mark(isList(X)) -> active(isList(X)),
                                        mark(isQid(X)) -> active(isQid(X)),
                                      mark(isNePal(X)) -> active(isNePal(X)),
                                        mark(isPal(X)) -> active(isPal(X)),
                                             mark(a()) -> active(a()),
                                             mark(e()) -> active(e()),
                                             mark(i()) -> active(i()),
                                             mark(o()) -> active(o()),
                                             mark(u()) -> active(u()),
                                      __(X1, mark(X2)) -> __(X1, X2),
                                    __(X1, active(X2)) -> __(X1, X2),
                                      __(mark(X1), X2) -> __(X1, X2),
                                    __(active(X1), X2) -> __(X1, X2),
                                  active(__(X, nil())) -> mark(X),
                               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                  active(__(nil(), X)) -> mark(X),
                                  active(and(tt(), X)) -> mark(X),
                                   active(isNeList(V)) -> mark(isQid(V)),
                          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                     active(isList(V)) -> mark(isNeList(V)),
                            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                 active(isList(nil())) -> mark(tt()),
                                    active(isQid(a())) -> mark(tt()),
                                    active(isQid(e())) -> mark(tt()),
                                    active(isQid(i())) -> mark(tt()),
                                    active(isQid(o())) -> mark(tt()),
                                    active(isQid(u())) -> mark(tt()),
                                    active(isNePal(V)) -> mark(isQid(V)),
                      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                      active(isPal(V)) -> mark(isNePal(V)),
                                  active(isPal(nil())) -> mark(tt()),
                                     and(X1, mark(X2)) -> and(X1, X2),
                                   and(X1, active(X2)) -> and(X1, X2),
                                     and(mark(X1), X2) -> and(X1, X2),
                                   and(active(X1), X2) -> and(X1, X2),
                                     isNeList(mark(X)) -> isNeList(X),
                                   isNeList(active(X)) -> isNeList(X),
                                       isList(mark(X)) -> isList(X),
                                     isList(active(X)) -> isList(X),
                                        isQid(mark(X)) -> isQid(X),
                                      isQid(active(X)) -> isQid(X),
                                      isNePal(mark(X)) -> isNePal(X),
                                    isNePal(active(X)) -> isNePal(X),
                                        isPal(mark(X)) -> isPal(X),
                                      isPal(active(X)) -> isPal(X)}
                     POLY:
                      Argument Filtering:
                       pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = 0, pi(nil) = [], pi(active#) = [], pi(active) = 0, pi(__) = [], pi(mark#) = 0, pi(mark) = 0
                      Usable Rules:
                       {}
                      Interpretation:
                       [active#] = 0,
                       [__] = 0,
                       [isPal] = 0,
                       [isNePal] = 0,
                       [isQid] = 0,
                       [isList] = 1,
                       [isNeList] = 0
                      Strict:
                       {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                       mark#(and(X1, X2)) -> mark#(X1),
                                       mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                       mark#(isNeList(X)) -> active#(isNeList(X)),
                                        mark#(isNePal(X)) -> active#(isNePal(X)),
                                          mark#(isPal(X)) -> active#(isPal(X)),
                                 active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                     active#(isNeList(V)) -> mark#(isQid(V)),
                                       active#(isList(V)) -> mark#(isNeList(V)),
                                      active#(isNePal(V)) -> mark#(isQid(V)),
                        active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                        active#(isPal(V)) -> mark#(isNePal(V))}
                      Weak:
                       {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                             mark(nil()) -> active(nil()),
                                       mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                              mark(tt()) -> active(tt()),
                                       mark(isNeList(X)) -> active(isNeList(X)),
                                         mark(isList(X)) -> active(isList(X)),
                                          mark(isQid(X)) -> active(isQid(X)),
                                        mark(isNePal(X)) -> active(isNePal(X)),
                                          mark(isPal(X)) -> active(isPal(X)),
                                               mark(a()) -> active(a()),
                                               mark(e()) -> active(e()),
                                               mark(i()) -> active(i()),
                                               mark(o()) -> active(o()),
                                               mark(u()) -> active(u()),
                                        __(X1, mark(X2)) -> __(X1, X2),
                                      __(X1, active(X2)) -> __(X1, X2),
                                        __(mark(X1), X2) -> __(X1, X2),
                                      __(active(X1), X2) -> __(X1, X2),
                                    active(__(X, nil())) -> mark(X),
                                 active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                    active(__(nil(), X)) -> mark(X),
                                    active(and(tt(), X)) -> mark(X),
                                     active(isNeList(V)) -> mark(isQid(V)),
                            active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                            active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                       active(isList(V)) -> mark(isNeList(V)),
                              active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                   active(isList(nil())) -> mark(tt()),
                                      active(isQid(a())) -> mark(tt()),
                                      active(isQid(e())) -> mark(tt()),
                                      active(isQid(i())) -> mark(tt()),
                                      active(isQid(o())) -> mark(tt()),
                                      active(isQid(u())) -> mark(tt()),
                                      active(isNePal(V)) -> mark(isQid(V)),
                        active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                        active(isPal(V)) -> mark(isNePal(V)),
                                    active(isPal(nil())) -> mark(tt()),
                                       and(X1, mark(X2)) -> and(X1, X2),
                                     and(X1, active(X2)) -> and(X1, X2),
                                       and(mark(X1), X2) -> and(X1, X2),
                                     and(active(X1), X2) -> and(X1, X2),
                                       isNeList(mark(X)) -> isNeList(X),
                                     isNeList(active(X)) -> isNeList(X),
                                         isList(mark(X)) -> isList(X),
                                       isList(active(X)) -> isList(X),
                                          isQid(mark(X)) -> isQid(X),
                                        isQid(active(X)) -> isQid(X),
                                        isNePal(mark(X)) -> isNePal(X),
                                      isNePal(active(X)) -> isNePal(X),
                                          isPal(mark(X)) -> isPal(X),
                                        isPal(active(X)) -> isPal(X)}
                      EDG:
                       {(mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))
                        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
                        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
                        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
                        (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isPal(X)) -> active#(isPal(X)))
                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isPal(X)) -> active#(isPal(X)))
                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                        (mark#(isPal(X)) -> active#(isPal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                        (mark#(isPal(X)) -> active#(isPal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                        (mark#(isPal(X)) -> active#(isPal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                        (mark#(isPal(X)) -> active#(isPal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
                        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isPal(X)) -> active#(isPal(X)))
                        (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
                        (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (active#(isList(V)) -> mark#(isNeList(V)), mark#(isPal(X)) -> active#(isPal(X)))
                        (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                        (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (mark#(and(X1, X2)) -> mark#(X1), mark#(isPal(X)) -> active#(isPal(X)))
                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isPal(X)) -> active#(isPal(X)))}
                       SCCS:
                        Scc:
                         {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                         mark#(and(X1, X2)) -> mark#(X1),
                                         mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                         mark#(isNeList(X)) -> active#(isNeList(X)),
                                          mark#(isNePal(X)) -> active#(isNePal(X)),
                                            mark#(isPal(X)) -> active#(isPal(X)),
                                   active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                       active#(isNeList(V)) -> mark#(isQid(V)),
                                         active#(isList(V)) -> mark#(isNeList(V)),
                                        active#(isNePal(V)) -> mark#(isQid(V)),
                          active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                          active#(isPal(V)) -> mark#(isNePal(V))}
                        SCC:
                         Strict:
                          {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                          mark#(and(X1, X2)) -> mark#(X1),
                                          mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                          mark#(isNeList(X)) -> active#(isNeList(X)),
                                           mark#(isNePal(X)) -> active#(isNePal(X)),
                                             mark#(isPal(X)) -> active#(isPal(X)),
                                    active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                        active#(isNeList(V)) -> mark#(isQid(V)),
                                          active#(isList(V)) -> mark#(isNeList(V)),
                                         active#(isNePal(V)) -> mark#(isQid(V)),
                           active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                           active#(isPal(V)) -> mark#(isNePal(V))}
                         Weak:
                         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                               mark(nil()) -> active(nil()),
                                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                mark(tt()) -> active(tt()),
                                         mark(isNeList(X)) -> active(isNeList(X)),
                                           mark(isList(X)) -> active(isList(X)),
                                            mark(isQid(X)) -> active(isQid(X)),
                                          mark(isNePal(X)) -> active(isNePal(X)),
                                            mark(isPal(X)) -> active(isPal(X)),
                                                 mark(a()) -> active(a()),
                                                 mark(e()) -> active(e()),
                                                 mark(i()) -> active(i()),
                                                 mark(o()) -> active(o()),
                                                 mark(u()) -> active(u()),
                                          __(X1, mark(X2)) -> __(X1, X2),
                                        __(X1, active(X2)) -> __(X1, X2),
                                          __(mark(X1), X2) -> __(X1, X2),
                                        __(active(X1), X2) -> __(X1, X2),
                                      active(__(X, nil())) -> mark(X),
                                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                      active(__(nil(), X)) -> mark(X),
                                      active(and(tt(), X)) -> mark(X),
                                       active(isNeList(V)) -> mark(isQid(V)),
                              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                         active(isList(V)) -> mark(isNeList(V)),
                                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                     active(isList(nil())) -> mark(tt()),
                                        active(isQid(a())) -> mark(tt()),
                                        active(isQid(e())) -> mark(tt()),
                                        active(isQid(i())) -> mark(tt()),
                                        active(isQid(o())) -> mark(tt()),
                                        active(isQid(u())) -> mark(tt()),
                                        active(isNePal(V)) -> mark(isQid(V)),
                          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                          active(isPal(V)) -> mark(isNePal(V)),
                                      active(isPal(nil())) -> mark(tt()),
                                         and(X1, mark(X2)) -> and(X1, X2),
                                       and(X1, active(X2)) -> and(X1, X2),
                                         and(mark(X1), X2) -> and(X1, X2),
                                       and(active(X1), X2) -> and(X1, X2),
                                         isNeList(mark(X)) -> isNeList(X),
                                       isNeList(active(X)) -> isNeList(X),
                                           isList(mark(X)) -> isList(X),
                                         isList(active(X)) -> isList(X),
                                            isQid(mark(X)) -> isQid(X),
                                          isQid(active(X)) -> isQid(X),
                                          isNePal(mark(X)) -> isNePal(X),
                                        isNePal(active(X)) -> isNePal(X),
                                            isPal(mark(X)) -> isPal(X),
                                          isPal(active(X)) -> isPal(X)}
                         POLY:
                          Argument Filtering:
                           pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = 0, pi(nil) = [], pi(active#) = [], pi(active) = [0], pi(__) = [], pi(mark#) = 0, pi(mark) = 0
                          Usable Rules:
                           {}
                          Interpretation:
                           [active#] = 0,
                           [__] = 0,
                           [isPal] = 1,
                           [isNePal] = 0,
                           [isQid] = 0,
                           [isNeList] = 0
                          Strict:
                           {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                           mark#(and(X1, X2)) -> mark#(X1),
                                           mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                           mark#(isNeList(X)) -> active#(isNeList(X)),
                                            mark#(isNePal(X)) -> active#(isNePal(X)),
                                     active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                         active#(isNeList(V)) -> mark#(isQid(V)),
                                           active#(isList(V)) -> mark#(isNeList(V)),
                                          active#(isNePal(V)) -> mark#(isQid(V)),
                            active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                            active#(isPal(V)) -> mark#(isNePal(V))}
                          Weak:
                           {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                 mark(nil()) -> active(nil()),
                                           mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                  mark(tt()) -> active(tt()),
                                           mark(isNeList(X)) -> active(isNeList(X)),
                                             mark(isList(X)) -> active(isList(X)),
                                              mark(isQid(X)) -> active(isQid(X)),
                                            mark(isNePal(X)) -> active(isNePal(X)),
                                              mark(isPal(X)) -> active(isPal(X)),
                                                   mark(a()) -> active(a()),
                                                   mark(e()) -> active(e()),
                                                   mark(i()) -> active(i()),
                                                   mark(o()) -> active(o()),
                                                   mark(u()) -> active(u()),
                                            __(X1, mark(X2)) -> __(X1, X2),
                                          __(X1, active(X2)) -> __(X1, X2),
                                            __(mark(X1), X2) -> __(X1, X2),
                                          __(active(X1), X2) -> __(X1, X2),
                                        active(__(X, nil())) -> mark(X),
                                     active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                        active(__(nil(), X)) -> mark(X),
                                        active(and(tt(), X)) -> mark(X),
                                         active(isNeList(V)) -> mark(isQid(V)),
                                active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                           active(isList(V)) -> mark(isNeList(V)),
                                  active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                       active(isList(nil())) -> mark(tt()),
                                          active(isQid(a())) -> mark(tt()),
                                          active(isQid(e())) -> mark(tt()),
                                          active(isQid(i())) -> mark(tt()),
                                          active(isQid(o())) -> mark(tt()),
                                          active(isQid(u())) -> mark(tt()),
                                          active(isNePal(V)) -> mark(isQid(V)),
                            active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                            active(isPal(V)) -> mark(isNePal(V)),
                                        active(isPal(nil())) -> mark(tt()),
                                           and(X1, mark(X2)) -> and(X1, X2),
                                         and(X1, active(X2)) -> and(X1, X2),
                                           and(mark(X1), X2) -> and(X1, X2),
                                         and(active(X1), X2) -> and(X1, X2),
                                           isNeList(mark(X)) -> isNeList(X),
                                         isNeList(active(X)) -> isNeList(X),
                                             isList(mark(X)) -> isList(X),
                                           isList(active(X)) -> isList(X),
                                              isQid(mark(X)) -> isQid(X),
                                            isQid(active(X)) -> isQid(X),
                                            isNePal(mark(X)) -> isNePal(X),
                                          isNePal(active(X)) -> isNePal(X),
                                              isPal(mark(X)) -> isPal(X),
                                            isPal(active(X)) -> isPal(X)}
                          EDG:
                           {(mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isPal(V)) -> mark#(isNePal(V)))
                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                            (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isPal(V)) -> mark#(isNePal(V)))
                            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> mark#(X1))
                            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (active#(isPal(V)) -> mark#(isNePal(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
                            (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                            (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                            (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                            (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                            (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
                            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
                            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
                            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                            (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isPal(V)) -> mark#(isNePal(V)))}
                           SCCS:
                            Scc:
                             {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                             mark#(and(X1, X2)) -> mark#(X1),
                                             mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                             mark#(isNeList(X)) -> active#(isNeList(X)),
                                              mark#(isNePal(X)) -> active#(isNePal(X)),
                                       active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                           active#(isNeList(V)) -> mark#(isQid(V)),
                                             active#(isList(V)) -> mark#(isNeList(V)),
                                            active#(isNePal(V)) -> mark#(isQid(V)),
                              active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                              active#(isPal(V)) -> mark#(isNePal(V))}
                            SCC:
                             Strict:
                              {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                              mark#(and(X1, X2)) -> mark#(X1),
                                              mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                              mark#(isNeList(X)) -> active#(isNeList(X)),
                                               mark#(isNePal(X)) -> active#(isNePal(X)),
                                        active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                            active#(isNeList(V)) -> mark#(isQid(V)),
                                              active#(isList(V)) -> mark#(isNeList(V)),
                                             active#(isNePal(V)) -> mark#(isQid(V)),
                               active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))),
                                               active#(isPal(V)) -> mark#(isNePal(V))}
                             Weak:
                             {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                   mark(nil()) -> active(nil()),
                                             mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                    mark(tt()) -> active(tt()),
                                             mark(isNeList(X)) -> active(isNeList(X)),
                                               mark(isList(X)) -> active(isList(X)),
                                                mark(isQid(X)) -> active(isQid(X)),
                                              mark(isNePal(X)) -> active(isNePal(X)),
                                                mark(isPal(X)) -> active(isPal(X)),
                                                     mark(a()) -> active(a()),
                                                     mark(e()) -> active(e()),
                                                     mark(i()) -> active(i()),
                                                     mark(o()) -> active(o()),
                                                     mark(u()) -> active(u()),
                                              __(X1, mark(X2)) -> __(X1, X2),
                                            __(X1, active(X2)) -> __(X1, X2),
                                              __(mark(X1), X2) -> __(X1, X2),
                                            __(active(X1), X2) -> __(X1, X2),
                                          active(__(X, nil())) -> mark(X),
                                       active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                          active(__(nil(), X)) -> mark(X),
                                          active(and(tt(), X)) -> mark(X),
                                           active(isNeList(V)) -> mark(isQid(V)),
                                  active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                  active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                             active(isList(V)) -> mark(isNeList(V)),
                                    active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                         active(isList(nil())) -> mark(tt()),
                                            active(isQid(a())) -> mark(tt()),
                                            active(isQid(e())) -> mark(tt()),
                                            active(isQid(i())) -> mark(tt()),
                                            active(isQid(o())) -> mark(tt()),
                                            active(isQid(u())) -> mark(tt()),
                                            active(isNePal(V)) -> mark(isQid(V)),
                              active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                              active(isPal(V)) -> mark(isNePal(V)),
                                          active(isPal(nil())) -> mark(tt()),
                                             and(X1, mark(X2)) -> and(X1, X2),
                                           and(X1, active(X2)) -> and(X1, X2),
                                             and(mark(X1), X2) -> and(X1, X2),
                                           and(active(X1), X2) -> and(X1, X2),
                                             isNeList(mark(X)) -> isNeList(X),
                                           isNeList(active(X)) -> isNeList(X),
                                               isList(mark(X)) -> isList(X),
                                             isList(active(X)) -> isList(X),
                                                isQid(mark(X)) -> isQid(X),
                                              isQid(active(X)) -> isQid(X),
                                              isNePal(mark(X)) -> isNePal(X),
                                            isNePal(active(X)) -> isNePal(X),
                                                isPal(mark(X)) -> isPal(X),
                                              isPal(active(X)) -> isPal(X)}
                             POLY:
                              Argument Filtering:
                               pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [], pi(nil) = [], pi(active#) = 0, pi(active) = [], pi(__) = [], pi(mark#) = [], pi(mark) = []
                              Usable Rules:
                               {}
                              Interpretation:
                               [mark#] = 0,
                               [and] = 0,
                               [__] = 0,
                               [isPal] = 1,
                               [isNePal] = 0,
                               [isList] = 0,
                               [isNeList] = 0
                              Strict:
                               {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                               mark#(and(X1, X2)) -> mark#(X1),
                                               mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                               mark#(isNeList(X)) -> active#(isNeList(X)),
                                                mark#(isNePal(X)) -> active#(isNePal(X)),
                                         active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                             active#(isNeList(V)) -> mark#(isQid(V)),
                                               active#(isList(V)) -> mark#(isNeList(V)),
                                              active#(isNePal(V)) -> mark#(isQid(V)),
                                active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                              Weak:
                               {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                     mark(nil()) -> active(nil()),
                                               mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                      mark(tt()) -> active(tt()),
                                               mark(isNeList(X)) -> active(isNeList(X)),
                                                 mark(isList(X)) -> active(isList(X)),
                                                  mark(isQid(X)) -> active(isQid(X)),
                                                mark(isNePal(X)) -> active(isNePal(X)),
                                                  mark(isPal(X)) -> active(isPal(X)),
                                                       mark(a()) -> active(a()),
                                                       mark(e()) -> active(e()),
                                                       mark(i()) -> active(i()),
                                                       mark(o()) -> active(o()),
                                                       mark(u()) -> active(u()),
                                                __(X1, mark(X2)) -> __(X1, X2),
                                              __(X1, active(X2)) -> __(X1, X2),
                                                __(mark(X1), X2) -> __(X1, X2),
                                              __(active(X1), X2) -> __(X1, X2),
                                            active(__(X, nil())) -> mark(X),
                                         active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                            active(__(nil(), X)) -> mark(X),
                                            active(and(tt(), X)) -> mark(X),
                                             active(isNeList(V)) -> mark(isQid(V)),
                                    active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                    active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                               active(isList(V)) -> mark(isNeList(V)),
                                      active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                           active(isList(nil())) -> mark(tt()),
                                              active(isQid(a())) -> mark(tt()),
                                              active(isQid(e())) -> mark(tt()),
                                              active(isQid(i())) -> mark(tt()),
                                              active(isQid(o())) -> mark(tt()),
                                              active(isQid(u())) -> mark(tt()),
                                              active(isNePal(V)) -> mark(isQid(V)),
                                active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                active(isPal(V)) -> mark(isNePal(V)),
                                            active(isPal(nil())) -> mark(tt()),
                                               and(X1, mark(X2)) -> and(X1, X2),
                                             and(X1, active(X2)) -> and(X1, X2),
                                               and(mark(X1), X2) -> and(X1, X2),
                                             and(active(X1), X2) -> and(X1, X2),
                                               isNeList(mark(X)) -> isNeList(X),
                                             isNeList(active(X)) -> isNeList(X),
                                                 isList(mark(X)) -> isList(X),
                                               isList(active(X)) -> isList(X),
                                                  isQid(mark(X)) -> isQid(X),
                                                isQid(active(X)) -> isQid(X),
                                                isNePal(mark(X)) -> isNePal(X),
                                              isNePal(active(X)) -> isNePal(X),
                                                  isPal(mark(X)) -> isPal(X),
                                                isPal(active(X)) -> isPal(X)}
                              EDG:
                               {(active#(isList(V)) -> mark#(isNeList(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                                (active#(isList(V)) -> mark#(isNeList(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                (active#(isList(V)) -> mark#(isNeList(V)), mark#(and(X1, X2)) -> mark#(X1))
                                (active#(isList(V)) -> mark#(isNeList(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isList(V)) -> mark#(isNeList(V)))
                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                                (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                                (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                                (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
                                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isList(V)) -> mark#(isNeList(V)))
                                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
                                (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isList(V)) -> mark#(isNeList(V)))
                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isList(V)) -> mark#(isNeList(V)))
                                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))}
                               SCCS:
                                Scc:
                                 {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                 mark#(and(X1, X2)) -> mark#(X1),
                                                 mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                                 mark#(isNeList(X)) -> active#(isNeList(X)),
                                                  mark#(isNePal(X)) -> active#(isNePal(X)),
                                           active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                               active#(isNeList(V)) -> mark#(isQid(V)),
                                                 active#(isList(V)) -> mark#(isNeList(V)),
                                                active#(isNePal(V)) -> mark#(isQid(V)),
                                  active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                SCC:
                                 Strict:
                                  {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                  mark#(and(X1, X2)) -> mark#(X1),
                                                  mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                                  mark#(isNeList(X)) -> active#(isNeList(X)),
                                                   mark#(isNePal(X)) -> active#(isNePal(X)),
                                            active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                active#(isNeList(V)) -> mark#(isQid(V)),
                                                  active#(isList(V)) -> mark#(isNeList(V)),
                                                 active#(isNePal(V)) -> mark#(isQid(V)),
                                   active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                 Weak:
                                 {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                       mark(nil()) -> active(nil()),
                                                 mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                        mark(tt()) -> active(tt()),
                                                 mark(isNeList(X)) -> active(isNeList(X)),
                                                   mark(isList(X)) -> active(isList(X)),
                                                    mark(isQid(X)) -> active(isQid(X)),
                                                  mark(isNePal(X)) -> active(isNePal(X)),
                                                    mark(isPal(X)) -> active(isPal(X)),
                                                         mark(a()) -> active(a()),
                                                         mark(e()) -> active(e()),
                                                         mark(i()) -> active(i()),
                                                         mark(o()) -> active(o()),
                                                         mark(u()) -> active(u()),
                                                  __(X1, mark(X2)) -> __(X1, X2),
                                                __(X1, active(X2)) -> __(X1, X2),
                                                  __(mark(X1), X2) -> __(X1, X2),
                                                __(active(X1), X2) -> __(X1, X2),
                                              active(__(X, nil())) -> mark(X),
                                           active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                              active(__(nil(), X)) -> mark(X),
                                              active(and(tt(), X)) -> mark(X),
                                               active(isNeList(V)) -> mark(isQid(V)),
                                      active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                      active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                 active(isList(V)) -> mark(isNeList(V)),
                                        active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                             active(isList(nil())) -> mark(tt()),
                                                active(isQid(a())) -> mark(tt()),
                                                active(isQid(e())) -> mark(tt()),
                                                active(isQid(i())) -> mark(tt()),
                                                active(isQid(o())) -> mark(tt()),
                                                active(isQid(u())) -> mark(tt()),
                                                active(isNePal(V)) -> mark(isQid(V)),
                                  active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                  active(isPal(V)) -> mark(isNePal(V)),
                                              active(isPal(nil())) -> mark(tt()),
                                                 and(X1, mark(X2)) -> and(X1, X2),
                                               and(X1, active(X2)) -> and(X1, X2),
                                                 and(mark(X1), X2) -> and(X1, X2),
                                               and(active(X1), X2) -> and(X1, X2),
                                                 isNeList(mark(X)) -> isNeList(X),
                                               isNeList(active(X)) -> isNeList(X),
                                                   isList(mark(X)) -> isList(X),
                                                 isList(active(X)) -> isList(X),
                                                    isQid(mark(X)) -> isQid(X),
                                                  isQid(active(X)) -> isQid(X),
                                                  isNePal(mark(X)) -> isNePal(X),
                                                isNePal(active(X)) -> isNePal(X),
                                                    isPal(mark(X)) -> isPal(X),
                                                  isPal(active(X)) -> isPal(X)}
                                 POLY:
                                  Argument Filtering:
                                   pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [], pi(nil) = [], pi(active#) = 0, pi(active) = [], pi(__) = [], pi(mark#) = [], pi(mark) = []
                                  Usable Rules:
                                   {}
                                  Interpretation:
                                   [mark#] = 0,
                                   [and] = 0,
                                   [__] = 0,
                                   [isNePal] = 0,
                                   [isList] = 1,
                                   [isNeList] = 0
                                  Strict:
                                   {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                   mark#(and(X1, X2)) -> mark#(X1),
                                                   mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                                   mark#(isNeList(X)) -> active#(isNeList(X)),
                                                    mark#(isNePal(X)) -> active#(isNePal(X)),
                                             active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                 active#(isNeList(V)) -> mark#(isQid(V)),
                                                  active#(isNePal(V)) -> mark#(isQid(V)),
                                    active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                  Weak:
                                   {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                         mark(nil()) -> active(nil()),
                                                   mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                          mark(tt()) -> active(tt()),
                                                   mark(isNeList(X)) -> active(isNeList(X)),
                                                     mark(isList(X)) -> active(isList(X)),
                                                      mark(isQid(X)) -> active(isQid(X)),
                                                    mark(isNePal(X)) -> active(isNePal(X)),
                                                      mark(isPal(X)) -> active(isPal(X)),
                                                           mark(a()) -> active(a()),
                                                           mark(e()) -> active(e()),
                                                           mark(i()) -> active(i()),
                                                           mark(o()) -> active(o()),
                                                           mark(u()) -> active(u()),
                                                    __(X1, mark(X2)) -> __(X1, X2),
                                                  __(X1, active(X2)) -> __(X1, X2),
                                                    __(mark(X1), X2) -> __(X1, X2),
                                                  __(active(X1), X2) -> __(X1, X2),
                                                active(__(X, nil())) -> mark(X),
                                             active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                active(__(nil(), X)) -> mark(X),
                                                active(and(tt(), X)) -> mark(X),
                                                 active(isNeList(V)) -> mark(isQid(V)),
                                        active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                        active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                   active(isList(V)) -> mark(isNeList(V)),
                                          active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                               active(isList(nil())) -> mark(tt()),
                                                  active(isQid(a())) -> mark(tt()),
                                                  active(isQid(e())) -> mark(tt()),
                                                  active(isQid(i())) -> mark(tt()),
                                                  active(isQid(o())) -> mark(tt()),
                                                  active(isQid(u())) -> mark(tt()),
                                                  active(isNePal(V)) -> mark(isQid(V)),
                                    active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                    active(isPal(V)) -> mark(isNePal(V)),
                                                active(isPal(nil())) -> mark(tt()),
                                                   and(X1, mark(X2)) -> and(X1, X2),
                                                 and(X1, active(X2)) -> and(X1, X2),
                                                   and(mark(X1), X2) -> and(X1, X2),
                                                 and(active(X1), X2) -> and(X1, X2),
                                                   isNeList(mark(X)) -> isNeList(X),
                                                 isNeList(active(X)) -> isNeList(X),
                                                     isList(mark(X)) -> isList(X),
                                                   isList(active(X)) -> isList(X),
                                                      isQid(mark(X)) -> isQid(X),
                                                    isQid(active(X)) -> isQid(X),
                                                    isNePal(mark(X)) -> isNePal(X),
                                                  isNePal(active(X)) -> isNePal(X),
                                                      isPal(mark(X)) -> isPal(X),
                                                    isPal(active(X)) -> isPal(X)}
                                  EDG:
                                   {(active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                                    (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                    (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNeList(V)) -> mark#(isQid(V)))
                                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(V)) -> mark#(isQid(V)))
                                    (mark#(and(X1, X2)) -> active#(and(mark(X1), X2)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                    (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                    (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                                    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                                    (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> active#(and(mark(X1), X2)))
                                    (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                                    (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))
                                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))}
                                   SCCS:
                                    Scc:
                                     {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                     mark#(and(X1, X2)) -> mark#(X1),
                                                     mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                                     mark#(isNeList(X)) -> active#(isNeList(X)),
                                                      mark#(isNePal(X)) -> active#(isNePal(X)),
                                               active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                   active#(isNeList(V)) -> mark#(isQid(V)),
                                                    active#(isNePal(V)) -> mark#(isQid(V)),
                                      active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                    SCC:
                                     Strict:
                                      {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                      mark#(and(X1, X2)) -> mark#(X1),
                                                      mark#(and(X1, X2)) -> active#(and(mark(X1), X2)),
                                                      mark#(isNeList(X)) -> active#(isNeList(X)),
                                                       mark#(isNePal(X)) -> active#(isNePal(X)),
                                                active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                    active#(isNeList(V)) -> mark#(isQid(V)),
                                                     active#(isNePal(V)) -> mark#(isQid(V)),
                                       active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                     Weak:
                                     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                           mark(nil()) -> active(nil()),
                                                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                            mark(tt()) -> active(tt()),
                                                     mark(isNeList(X)) -> active(isNeList(X)),
                                                       mark(isList(X)) -> active(isList(X)),
                                                        mark(isQid(X)) -> active(isQid(X)),
                                                      mark(isNePal(X)) -> active(isNePal(X)),
                                                        mark(isPal(X)) -> active(isPal(X)),
                                                             mark(a()) -> active(a()),
                                                             mark(e()) -> active(e()),
                                                             mark(i()) -> active(i()),
                                                             mark(o()) -> active(o()),
                                                             mark(u()) -> active(u()),
                                                      __(X1, mark(X2)) -> __(X1, X2),
                                                    __(X1, active(X2)) -> __(X1, X2),
                                                      __(mark(X1), X2) -> __(X1, X2),
                                                    __(active(X1), X2) -> __(X1, X2),
                                                  active(__(X, nil())) -> mark(X),
                                               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                  active(__(nil(), X)) -> mark(X),
                                                  active(and(tt(), X)) -> mark(X),
                                                   active(isNeList(V)) -> mark(isQid(V)),
                                          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                     active(isList(V)) -> mark(isNeList(V)),
                                            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                 active(isList(nil())) -> mark(tt()),
                                                    active(isQid(a())) -> mark(tt()),
                                                    active(isQid(e())) -> mark(tt()),
                                                    active(isQid(i())) -> mark(tt()),
                                                    active(isQid(o())) -> mark(tt()),
                                                    active(isQid(u())) -> mark(tt()),
                                                    active(isNePal(V)) -> mark(isQid(V)),
                                      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                      active(isPal(V)) -> mark(isNePal(V)),
                                                  active(isPal(nil())) -> mark(tt()),
                                                     and(X1, mark(X2)) -> and(X1, X2),
                                                   and(X1, active(X2)) -> and(X1, X2),
                                                     and(mark(X1), X2) -> and(X1, X2),
                                                   and(active(X1), X2) -> and(X1, X2),
                                                     isNeList(mark(X)) -> isNeList(X),
                                                   isNeList(active(X)) -> isNeList(X),
                                                       isList(mark(X)) -> isList(X),
                                                     isList(active(X)) -> isList(X),
                                                        isQid(mark(X)) -> isQid(X),
                                                      isQid(active(X)) -> isQid(X),
                                                      isNePal(mark(X)) -> isNePal(X),
                                                    isNePal(active(X)) -> isNePal(X),
                                                        isPal(mark(X)) -> isPal(X),
                                                      isPal(active(X)) -> isPal(X)}
                                     POLY:
                                      Argument Filtering:
                                       pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [], pi(nil) = [], pi(active#) = 0, pi(active) = [], pi(__) = [], pi(mark#) = [], pi(mark) = []
                                      Usable Rules:
                                       {}
                                      Interpretation:
                                       [mark#] = 1,
                                       [and] = 0,
                                       [__] = 1,
                                       [isNePal] = 1,
                                       [isNeList] = 1
                                      Strict:
                                       {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                       mark#(and(X1, X2)) -> mark#(X1),
                                                       mark#(isNeList(X)) -> active#(isNeList(X)),
                                                        mark#(isNePal(X)) -> active#(isNePal(X)),
                                                 active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                     active#(isNeList(V)) -> mark#(isQid(V)),
                                                      active#(isNePal(V)) -> mark#(isQid(V)),
                                        active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                      Weak:
                                       {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                             mark(nil()) -> active(nil()),
                                                       mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                              mark(tt()) -> active(tt()),
                                                       mark(isNeList(X)) -> active(isNeList(X)),
                                                         mark(isList(X)) -> active(isList(X)),
                                                          mark(isQid(X)) -> active(isQid(X)),
                                                        mark(isNePal(X)) -> active(isNePal(X)),
                                                          mark(isPal(X)) -> active(isPal(X)),
                                                               mark(a()) -> active(a()),
                                                               mark(e()) -> active(e()),
                                                               mark(i()) -> active(i()),
                                                               mark(o()) -> active(o()),
                                                               mark(u()) -> active(u()),
                                                        __(X1, mark(X2)) -> __(X1, X2),
                                                      __(X1, active(X2)) -> __(X1, X2),
                                                        __(mark(X1), X2) -> __(X1, X2),
                                                      __(active(X1), X2) -> __(X1, X2),
                                                    active(__(X, nil())) -> mark(X),
                                                 active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                    active(__(nil(), X)) -> mark(X),
                                                    active(and(tt(), X)) -> mark(X),
                                                     active(isNeList(V)) -> mark(isQid(V)),
                                            active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                            active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                       active(isList(V)) -> mark(isNeList(V)),
                                              active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                   active(isList(nil())) -> mark(tt()),
                                                      active(isQid(a())) -> mark(tt()),
                                                      active(isQid(e())) -> mark(tt()),
                                                      active(isQid(i())) -> mark(tt()),
                                                      active(isQid(o())) -> mark(tt()),
                                                      active(isQid(u())) -> mark(tt()),
                                                      active(isNePal(V)) -> mark(isQid(V)),
                                        active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                        active(isPal(V)) -> mark(isNePal(V)),
                                                    active(isPal(nil())) -> mark(tt()),
                                                       and(X1, mark(X2)) -> and(X1, X2),
                                                     and(X1, active(X2)) -> and(X1, X2),
                                                       and(mark(X1), X2) -> and(X1, X2),
                                                     and(active(X1), X2) -> and(X1, X2),
                                                       isNeList(mark(X)) -> isNeList(X),
                                                     isNeList(active(X)) -> isNeList(X),
                                                         isList(mark(X)) -> isList(X),
                                                       isList(active(X)) -> isList(X),
                                                          isQid(mark(X)) -> isQid(X),
                                                        isQid(active(X)) -> isQid(X),
                                                        isNePal(mark(X)) -> isNePal(X),
                                                      isNePal(active(X)) -> isNePal(X),
                                                          isPal(mark(X)) -> isPal(X),
                                                        isPal(active(X)) -> isPal(X)}
                                      EDG:
                                       {(active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                        (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNePal(X)) -> active#(isNePal(X)))
                                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                                        (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                        (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNePal(X)) -> active#(isNePal(X)))
                                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                        (mark#(isNePal(X)) -> active#(isNePal(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                        (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNePal(X)) -> active#(isNePal(X)))
                                        (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                        (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                                        (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                                        (mark#(and(X1, X2)) -> mark#(X1), mark#(isNePal(X)) -> active#(isNePal(X)))}
                                       SCCS:
                                        Scc:
                                         {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                         mark#(and(X1, X2)) -> mark#(X1),
                                                         mark#(isNeList(X)) -> active#(isNeList(X)),
                                                          mark#(isNePal(X)) -> active#(isNePal(X)),
                                                   active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                       active#(isNeList(V)) -> mark#(isQid(V)),
                                                        active#(isNePal(V)) -> mark#(isQid(V)),
                                          active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                        SCC:
                                         Strict:
                                          {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                          mark#(and(X1, X2)) -> mark#(X1),
                                                          mark#(isNeList(X)) -> active#(isNeList(X)),
                                                           mark#(isNePal(X)) -> active#(isNePal(X)),
                                                    active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                        active#(isNeList(V)) -> mark#(isQid(V)),
                                                         active#(isNePal(V)) -> mark#(isQid(V)),
                                           active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                         Weak:
                                         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                               mark(nil()) -> active(nil()),
                                                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                mark(tt()) -> active(tt()),
                                                         mark(isNeList(X)) -> active(isNeList(X)),
                                                           mark(isList(X)) -> active(isList(X)),
                                                            mark(isQid(X)) -> active(isQid(X)),
                                                          mark(isNePal(X)) -> active(isNePal(X)),
                                                            mark(isPal(X)) -> active(isPal(X)),
                                                                 mark(a()) -> active(a()),
                                                                 mark(e()) -> active(e()),
                                                                 mark(i()) -> active(i()),
                                                                 mark(o()) -> active(o()),
                                                                 mark(u()) -> active(u()),
                                                          __(X1, mark(X2)) -> __(X1, X2),
                                                        __(X1, active(X2)) -> __(X1, X2),
                                                          __(mark(X1), X2) -> __(X1, X2),
                                                        __(active(X1), X2) -> __(X1, X2),
                                                      active(__(X, nil())) -> mark(X),
                                                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                      active(__(nil(), X)) -> mark(X),
                                                      active(and(tt(), X)) -> mark(X),
                                                       active(isNeList(V)) -> mark(isQid(V)),
                                              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                         active(isList(V)) -> mark(isNeList(V)),
                                                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                     active(isList(nil())) -> mark(tt()),
                                                        active(isQid(a())) -> mark(tt()),
                                                        active(isQid(e())) -> mark(tt()),
                                                        active(isQid(i())) -> mark(tt()),
                                                        active(isQid(o())) -> mark(tt()),
                                                        active(isQid(u())) -> mark(tt()),
                                                        active(isNePal(V)) -> mark(isQid(V)),
                                          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                          active(isPal(V)) -> mark(isNePal(V)),
                                                      active(isPal(nil())) -> mark(tt()),
                                                         and(X1, mark(X2)) -> and(X1, X2),
                                                       and(X1, active(X2)) -> and(X1, X2),
                                                         and(mark(X1), X2) -> and(X1, X2),
                                                       and(active(X1), X2) -> and(X1, X2),
                                                         isNeList(mark(X)) -> isNeList(X),
                                                       isNeList(active(X)) -> isNeList(X),
                                                           isList(mark(X)) -> isList(X),
                                                         isList(active(X)) -> isList(X),
                                                            isQid(mark(X)) -> isQid(X),
                                                          isQid(active(X)) -> isQid(X),
                                                          isNePal(mark(X)) -> isNePal(X),
                                                        isNePal(active(X)) -> isNePal(X),
                                                            isPal(mark(X)) -> isPal(X),
                                                          isPal(active(X)) -> isPal(X)}
                                         POLY:
                                          Argument Filtering:
                                           pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = 0, pi(nil) = [], pi(active#) = [], pi(active) = 0, pi(__) = [], pi(mark#) = 0, pi(mark) = 0
                                          Usable Rules:
                                           {}
                                          Interpretation:
                                           [active#] = 0,
                                           [__] = 0,
                                           [isNePal] = 1,
                                           [isQid] = 0,
                                           [isNeList] = 0
                                          Strict:
                                           {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                           mark#(and(X1, X2)) -> mark#(X1),
                                                           mark#(isNeList(X)) -> active#(isNeList(X)),
                                                     active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                         active#(isNeList(V)) -> mark#(isQid(V)),
                                                          active#(isNePal(V)) -> mark#(isQid(V)),
                                            active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                          Weak:
                                           {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                 mark(nil()) -> active(nil()),
                                                           mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                  mark(tt()) -> active(tt()),
                                                           mark(isNeList(X)) -> active(isNeList(X)),
                                                             mark(isList(X)) -> active(isList(X)),
                                                              mark(isQid(X)) -> active(isQid(X)),
                                                            mark(isNePal(X)) -> active(isNePal(X)),
                                                              mark(isPal(X)) -> active(isPal(X)),
                                                                   mark(a()) -> active(a()),
                                                                   mark(e()) -> active(e()),
                                                                   mark(i()) -> active(i()),
                                                                   mark(o()) -> active(o()),
                                                                   mark(u()) -> active(u()),
                                                            __(X1, mark(X2)) -> __(X1, X2),
                                                          __(X1, active(X2)) -> __(X1, X2),
                                                            __(mark(X1), X2) -> __(X1, X2),
                                                          __(active(X1), X2) -> __(X1, X2),
                                                        active(__(X, nil())) -> mark(X),
                                                     active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                        active(__(nil(), X)) -> mark(X),
                                                        active(and(tt(), X)) -> mark(X),
                                                         active(isNeList(V)) -> mark(isQid(V)),
                                                active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                           active(isList(V)) -> mark(isNeList(V)),
                                                  active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                       active(isList(nil())) -> mark(tt()),
                                                          active(isQid(a())) -> mark(tt()),
                                                          active(isQid(e())) -> mark(tt()),
                                                          active(isQid(i())) -> mark(tt()),
                                                          active(isQid(o())) -> mark(tt()),
                                                          active(isQid(u())) -> mark(tt()),
                                                          active(isNePal(V)) -> mark(isQid(V)),
                                            active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                            active(isPal(V)) -> mark(isNePal(V)),
                                                        active(isPal(nil())) -> mark(tt()),
                                                           and(X1, mark(X2)) -> and(X1, X2),
                                                         and(X1, active(X2)) -> and(X1, X2),
                                                           and(mark(X1), X2) -> and(X1, X2),
                                                         and(active(X1), X2) -> and(X1, X2),
                                                           isNeList(mark(X)) -> isNeList(X),
                                                         isNeList(active(X)) -> isNeList(X),
                                                             isList(mark(X)) -> isList(X),
                                                           isList(active(X)) -> isList(X),
                                                              isQid(mark(X)) -> isQid(X),
                                                            isQid(active(X)) -> isQid(X),
                                                            isNePal(mark(X)) -> isNePal(X),
                                                          isNePal(active(X)) -> isNePal(X),
                                                              isPal(mark(X)) -> isPal(X),
                                                            isPal(active(X)) -> isPal(X)}
                                          EDG:
                                           {(active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                                            (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                            (active#(isNePal(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNePal(V)) -> mark#(isQid(V)))
                                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))
                                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(and(X1, X2)) -> mark#(X1))
                                            (active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(V)) -> mark#(isQid(V)))
                                            (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P))))
                                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                            (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                            (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                            (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                                            (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))}
                                           SCCS:
                                            Scc:
                                             {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                             mark#(and(X1, X2)) -> mark#(X1),
                                                             mark#(isNeList(X)) -> active#(isNeList(X)),
                                                       active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                           active#(isNeList(V)) -> mark#(isQid(V)),
                                                            active#(isNePal(V)) -> mark#(isQid(V)),
                                              active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                            SCC:
                                             Strict:
                                              {                mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                              mark#(and(X1, X2)) -> mark#(X1),
                                                              mark#(isNeList(X)) -> active#(isNeList(X)),
                                                        active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                            active#(isNeList(V)) -> mark#(isQid(V)),
                                                             active#(isNePal(V)) -> mark#(isQid(V)),
                                               active#(isNePal(__(I, __(P, I)))) -> mark#(and(isQid(I), isPal(P)))}
                                             Weak:
                                             {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                   mark(nil()) -> active(nil()),
                                                             mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                    mark(tt()) -> active(tt()),
                                                             mark(isNeList(X)) -> active(isNeList(X)),
                                                               mark(isList(X)) -> active(isList(X)),
                                                                mark(isQid(X)) -> active(isQid(X)),
                                                              mark(isNePal(X)) -> active(isNePal(X)),
                                                                mark(isPal(X)) -> active(isPal(X)),
                                                                     mark(a()) -> active(a()),
                                                                     mark(e()) -> active(e()),
                                                                     mark(i()) -> active(i()),
                                                                     mark(o()) -> active(o()),
                                                                     mark(u()) -> active(u()),
                                                              __(X1, mark(X2)) -> __(X1, X2),
                                                            __(X1, active(X2)) -> __(X1, X2),
                                                              __(mark(X1), X2) -> __(X1, X2),
                                                            __(active(X1), X2) -> __(X1, X2),
                                                          active(__(X, nil())) -> mark(X),
                                                       active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                          active(__(nil(), X)) -> mark(X),
                                                          active(and(tt(), X)) -> mark(X),
                                                           active(isNeList(V)) -> mark(isQid(V)),
                                                  active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                  active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                             active(isList(V)) -> mark(isNeList(V)),
                                                    active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                         active(isList(nil())) -> mark(tt()),
                                                            active(isQid(a())) -> mark(tt()),
                                                            active(isQid(e())) -> mark(tt()),
                                                            active(isQid(i())) -> mark(tt()),
                                                            active(isQid(o())) -> mark(tt()),
                                                            active(isQid(u())) -> mark(tt()),
                                                            active(isNePal(V)) -> mark(isQid(V)),
                                              active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                              active(isPal(V)) -> mark(isNePal(V)),
                                                          active(isPal(nil())) -> mark(tt()),
                                                             and(X1, mark(X2)) -> and(X1, X2),
                                                           and(X1, active(X2)) -> and(X1, X2),
                                                             and(mark(X1), X2) -> and(X1, X2),
                                                           and(active(X1), X2) -> and(X1, X2),
                                                             isNeList(mark(X)) -> isNeList(X),
                                                           isNeList(active(X)) -> isNeList(X),
                                                               isList(mark(X)) -> isList(X),
                                                             isList(active(X)) -> isList(X),
                                                                isQid(mark(X)) -> isQid(X),
                                                              isQid(active(X)) -> isQid(X),
                                                              isNePal(mark(X)) -> isNePal(X),
                                                            isNePal(active(X)) -> isNePal(X),
                                                                isPal(mark(X)) -> isPal(X),
                                                              isPal(active(X)) -> isPal(X)}
                                             POLY:
                                              Argument Filtering:
                                               pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [0], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = 0, pi(nil) = [], pi(active#) = 0, pi(active) = 0, pi(__) = [], pi(mark#) = 0, pi(mark) = 0
                                              Usable Rules:
                                               {}
                                              Interpretation:
                                               [__] = 1,
                                               [isNePal](x0) = x0 + 1,
                                               [isQid] = 0,
                                               [isNeList] = 0
                                              Strict:
                                               {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                      mark#(and(X1, X2)) -> mark#(X1),
                                                      mark#(isNeList(X)) -> active#(isNeList(X)),
                                                active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                    active#(isNeList(V)) -> mark#(isQid(V))}
                                              Weak:
                                               {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                     mark(nil()) -> active(nil()),
                                                               mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                      mark(tt()) -> active(tt()),
                                                               mark(isNeList(X)) -> active(isNeList(X)),
                                                                 mark(isList(X)) -> active(isList(X)),
                                                                  mark(isQid(X)) -> active(isQid(X)),
                                                                mark(isNePal(X)) -> active(isNePal(X)),
                                                                  mark(isPal(X)) -> active(isPal(X)),
                                                                       mark(a()) -> active(a()),
                                                                       mark(e()) -> active(e()),
                                                                       mark(i()) -> active(i()),
                                                                       mark(o()) -> active(o()),
                                                                       mark(u()) -> active(u()),
                                                                __(X1, mark(X2)) -> __(X1, X2),
                                                              __(X1, active(X2)) -> __(X1, X2),
                                                                __(mark(X1), X2) -> __(X1, X2),
                                                              __(active(X1), X2) -> __(X1, X2),
                                                            active(__(X, nil())) -> mark(X),
                                                         active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                            active(__(nil(), X)) -> mark(X),
                                                            active(and(tt(), X)) -> mark(X),
                                                             active(isNeList(V)) -> mark(isQid(V)),
                                                    active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                    active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                               active(isList(V)) -> mark(isNeList(V)),
                                                      active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                           active(isList(nil())) -> mark(tt()),
                                                              active(isQid(a())) -> mark(tt()),
                                                              active(isQid(e())) -> mark(tt()),
                                                              active(isQid(i())) -> mark(tt()),
                                                              active(isQid(o())) -> mark(tt()),
                                                              active(isQid(u())) -> mark(tt()),
                                                              active(isNePal(V)) -> mark(isQid(V)),
                                                active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                active(isPal(V)) -> mark(isNePal(V)),
                                                            active(isPal(nil())) -> mark(tt()),
                                                               and(X1, mark(X2)) -> and(X1, X2),
                                                             and(X1, active(X2)) -> and(X1, X2),
                                                               and(mark(X1), X2) -> and(X1, X2),
                                                             and(active(X1), X2) -> and(X1, X2),
                                                               isNeList(mark(X)) -> isNeList(X),
                                                             isNeList(active(X)) -> isNeList(X),
                                                                 isList(mark(X)) -> isList(X),
                                                               isList(active(X)) -> isList(X),
                                                                  isQid(mark(X)) -> isQid(X),
                                                                isQid(active(X)) -> isQid(X),
                                                                isNePal(mark(X)) -> isNePal(X),
                                                              isNePal(active(X)) -> isNePal(X),
                                                                  isPal(mark(X)) -> isPal(X),
                                                                isPal(active(X)) -> isPal(X)}
                                              EDG:
                                               {(active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(isNeList(X)) -> active#(isNeList(X)))
                                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                                                (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(isNeList(V)) -> mark#(isQid(V)))
                                                (mark#(isNeList(X)) -> active#(isNeList(X)), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                                (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                (mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                                                (mark#(and(X1, X2)) -> mark#(X1), mark#(isNeList(X)) -> active#(isNeList(X)))
                                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                                (active#(isNeList(V)) -> mark#(isQid(V)), mark#(isNeList(X)) -> active#(isNeList(X)))
                                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                                (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))}
                                               SCCS:
                                                Scc:
                                                 {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                        mark#(and(X1, X2)) -> mark#(X1),
                                                        mark#(isNeList(X)) -> active#(isNeList(X)),
                                                  active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                      active#(isNeList(V)) -> mark#(isQid(V))}
                                                SCC:
                                                 Strict:
                                                  {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                         mark#(and(X1, X2)) -> mark#(X1),
                                                         mark#(isNeList(X)) -> active#(isNeList(X)),
                                                   active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                       active#(isNeList(V)) -> mark#(isQid(V))}
                                                 Weak:
                                                 {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                       mark(nil()) -> active(nil()),
                                                                 mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                        mark(tt()) -> active(tt()),
                                                                 mark(isNeList(X)) -> active(isNeList(X)),
                                                                   mark(isList(X)) -> active(isList(X)),
                                                                    mark(isQid(X)) -> active(isQid(X)),
                                                                  mark(isNePal(X)) -> active(isNePal(X)),
                                                                    mark(isPal(X)) -> active(isPal(X)),
                                                                         mark(a()) -> active(a()),
                                                                         mark(e()) -> active(e()),
                                                                         mark(i()) -> active(i()),
                                                                         mark(o()) -> active(o()),
                                                                         mark(u()) -> active(u()),
                                                                  __(X1, mark(X2)) -> __(X1, X2),
                                                                __(X1, active(X2)) -> __(X1, X2),
                                                                  __(mark(X1), X2) -> __(X1, X2),
                                                                __(active(X1), X2) -> __(X1, X2),
                                                              active(__(X, nil())) -> mark(X),
                                                           active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                              active(__(nil(), X)) -> mark(X),
                                                              active(and(tt(), X)) -> mark(X),
                                                               active(isNeList(V)) -> mark(isQid(V)),
                                                      active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                      active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                 active(isList(V)) -> mark(isNeList(V)),
                                                        active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                             active(isList(nil())) -> mark(tt()),
                                                                active(isQid(a())) -> mark(tt()),
                                                                active(isQid(e())) -> mark(tt()),
                                                                active(isQid(i())) -> mark(tt()),
                                                                active(isQid(o())) -> mark(tt()),
                                                                active(isQid(u())) -> mark(tt()),
                                                                active(isNePal(V)) -> mark(isQid(V)),
                                                  active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                  active(isPal(V)) -> mark(isNePal(V)),
                                                              active(isPal(nil())) -> mark(tt()),
                                                                 and(X1, mark(X2)) -> and(X1, X2),
                                                               and(X1, active(X2)) -> and(X1, X2),
                                                                 and(mark(X1), X2) -> and(X1, X2),
                                                               and(active(X1), X2) -> and(X1, X2),
                                                                 isNeList(mark(X)) -> isNeList(X),
                                                               isNeList(active(X)) -> isNeList(X),
                                                                   isList(mark(X)) -> isList(X),
                                                                 isList(active(X)) -> isList(X),
                                                                    isQid(mark(X)) -> isQid(X),
                                                                  isQid(active(X)) -> isQid(X),
                                                                  isNePal(mark(X)) -> isNePal(X),
                                                                isNePal(active(X)) -> isNePal(X),
                                                                    isPal(mark(X)) -> isPal(X),
                                                                  isPal(active(X)) -> isPal(X)}
                                                 POLY:
                                                  Argument Filtering:
                                                   pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = 0, pi(nil) = [], pi(active#) = [], pi(active) = [], pi(__) = [], pi(mark#) = 0, pi(mark) = []
                                                  Usable Rules:
                                                   {}
                                                  Interpretation:
                                                   [active#] = 0,
                                                   [__] = 0,
                                                   [isQid] = 0,
                                                   [isNeList] = 1
                                                  Strict:
                                                   {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                          mark#(and(X1, X2)) -> mark#(X1),
                                                    active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                        active#(isNeList(V)) -> mark#(isQid(V))}
                                                  Weak:
                                                   {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                         mark(nil()) -> active(nil()),
                                                                   mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                          mark(tt()) -> active(tt()),
                                                                   mark(isNeList(X)) -> active(isNeList(X)),
                                                                     mark(isList(X)) -> active(isList(X)),
                                                                      mark(isQid(X)) -> active(isQid(X)),
                                                                    mark(isNePal(X)) -> active(isNePal(X)),
                                                                      mark(isPal(X)) -> active(isPal(X)),
                                                                           mark(a()) -> active(a()),
                                                                           mark(e()) -> active(e()),
                                                                           mark(i()) -> active(i()),
                                                                           mark(o()) -> active(o()),
                                                                           mark(u()) -> active(u()),
                                                                    __(X1, mark(X2)) -> __(X1, X2),
                                                                  __(X1, active(X2)) -> __(X1, X2),
                                                                    __(mark(X1), X2) -> __(X1, X2),
                                                                  __(active(X1), X2) -> __(X1, X2),
                                                                active(__(X, nil())) -> mark(X),
                                                             active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                                active(__(nil(), X)) -> mark(X),
                                                                active(and(tt(), X)) -> mark(X),
                                                                 active(isNeList(V)) -> mark(isQid(V)),
                                                        active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                        active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                   active(isList(V)) -> mark(isNeList(V)),
                                                          active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                               active(isList(nil())) -> mark(tt()),
                                                                  active(isQid(a())) -> mark(tt()),
                                                                  active(isQid(e())) -> mark(tt()),
                                                                  active(isQid(i())) -> mark(tt()),
                                                                  active(isQid(o())) -> mark(tt()),
                                                                  active(isQid(u())) -> mark(tt()),
                                                                  active(isNePal(V)) -> mark(isQid(V)),
                                                    active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                    active(isPal(V)) -> mark(isNePal(V)),
                                                                active(isPal(nil())) -> mark(tt()),
                                                                   and(X1, mark(X2)) -> and(X1, X2),
                                                                 and(X1, active(X2)) -> and(X1, X2),
                                                                   and(mark(X1), X2) -> and(X1, X2),
                                                                 and(active(X1), X2) -> and(X1, X2),
                                                                   isNeList(mark(X)) -> isNeList(X),
                                                                 isNeList(active(X)) -> isNeList(X),
                                                                     isList(mark(X)) -> isList(X),
                                                                   isList(active(X)) -> isList(X),
                                                                      isQid(mark(X)) -> isQid(X),
                                                                    isQid(active(X)) -> isQid(X),
                                                                    isNePal(mark(X)) -> isNePal(X),
                                                                  isNePal(active(X)) -> isNePal(X),
                                                                      isPal(mark(X)) -> isPal(X),
                                                                    isPal(active(X)) -> isPal(X)}
                                                  EDG:
                                                   {(mark#(and(X1, X2)) -> mark#(X1), mark#(and(X1, X2)) -> mark#(X1))
                                                    (mark#(and(X1, X2)) -> mark#(X1), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(and(X1, X2)) -> mark#(X1))
                                                    (active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                    (active#(isNeList(V)) -> mark#(isQid(V)), mark#(and(X1, X2)) -> mark#(X1))
                                                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                                    (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))}
                                                   SCCS:
                                                    Scc:
                                                     {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                            mark#(and(X1, X2)) -> mark#(X1),
                                                      active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                          active#(isNeList(V)) -> mark#(isQid(V))}
                                                    SCC:
                                                     Strict:
                                                      {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                             mark#(and(X1, X2)) -> mark#(X1),
                                                       active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                           active#(isNeList(V)) -> mark#(isQid(V))}
                                                     Weak:
                                                     {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                           mark(nil()) -> active(nil()),
                                                                     mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                            mark(tt()) -> active(tt()),
                                                                     mark(isNeList(X)) -> active(isNeList(X)),
                                                                       mark(isList(X)) -> active(isList(X)),
                                                                        mark(isQid(X)) -> active(isQid(X)),
                                                                      mark(isNePal(X)) -> active(isNePal(X)),
                                                                        mark(isPal(X)) -> active(isPal(X)),
                                                                             mark(a()) -> active(a()),
                                                                             mark(e()) -> active(e()),
                                                                             mark(i()) -> active(i()),
                                                                             mark(o()) -> active(o()),
                                                                             mark(u()) -> active(u()),
                                                                      __(X1, mark(X2)) -> __(X1, X2),
                                                                    __(X1, active(X2)) -> __(X1, X2),
                                                                      __(mark(X1), X2) -> __(X1, X2),
                                                                    __(active(X1), X2) -> __(X1, X2),
                                                                  active(__(X, nil())) -> mark(X),
                                                               active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                                  active(__(nil(), X)) -> mark(X),
                                                                  active(and(tt(), X)) -> mark(X),
                                                                   active(isNeList(V)) -> mark(isQid(V)),
                                                          active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                          active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                     active(isList(V)) -> mark(isNeList(V)),
                                                            active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                                 active(isList(nil())) -> mark(tt()),
                                                                    active(isQid(a())) -> mark(tt()),
                                                                    active(isQid(e())) -> mark(tt()),
                                                                    active(isQid(i())) -> mark(tt()),
                                                                    active(isQid(o())) -> mark(tt()),
                                                                    active(isQid(u())) -> mark(tt()),
                                                                    active(isNePal(V)) -> mark(isQid(V)),
                                                      active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                      active(isPal(V)) -> mark(isNePal(V)),
                                                                  active(isPal(nil())) -> mark(tt()),
                                                                     and(X1, mark(X2)) -> and(X1, X2),
                                                                   and(X1, active(X2)) -> and(X1, X2),
                                                                     and(mark(X1), X2) -> and(X1, X2),
                                                                   and(active(X1), X2) -> and(X1, X2),
                                                                     isNeList(mark(X)) -> isNeList(X),
                                                                   isNeList(active(X)) -> isNeList(X),
                                                                       isList(mark(X)) -> isList(X),
                                                                     isList(active(X)) -> isList(X),
                                                                        isQid(mark(X)) -> isQid(X),
                                                                      isQid(active(X)) -> isQid(X),
                                                                      isNePal(mark(X)) -> isNePal(X),
                                                                    isNePal(active(X)) -> isNePal(X),
                                                                        isPal(mark(X)) -> isPal(X),
                                                                      isPal(active(X)) -> isPal(X)}
                                                     POLY:
                                                      Argument Filtering:
                                                       pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [0], pi(nil) = [], pi(active#) = [], pi(active) = [], pi(__) = [], pi(mark#) = 0, pi(mark) = []
                                                      Usable Rules:
                                                       {}
                                                      Interpretation:
                                                       [active#] = 0,
                                                       [and](x0) = x0 + 1,
                                                       [__] = 0,
                                                       [isQid] = 0
                                                      Strict:
                                                       {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                        active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                            active#(isNeList(V)) -> mark#(isQid(V))}
                                                      Weak:
                                                       {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                             mark(nil()) -> active(nil()),
                                                                       mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                              mark(tt()) -> active(tt()),
                                                                       mark(isNeList(X)) -> active(isNeList(X)),
                                                                         mark(isList(X)) -> active(isList(X)),
                                                                          mark(isQid(X)) -> active(isQid(X)),
                                                                        mark(isNePal(X)) -> active(isNePal(X)),
                                                                          mark(isPal(X)) -> active(isPal(X)),
                                                                               mark(a()) -> active(a()),
                                                                               mark(e()) -> active(e()),
                                                                               mark(i()) -> active(i()),
                                                                               mark(o()) -> active(o()),
                                                                               mark(u()) -> active(u()),
                                                                        __(X1, mark(X2)) -> __(X1, X2),
                                                                      __(X1, active(X2)) -> __(X1, X2),
                                                                        __(mark(X1), X2) -> __(X1, X2),
                                                                      __(active(X1), X2) -> __(X1, X2),
                                                                    active(__(X, nil())) -> mark(X),
                                                                 active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                                    active(__(nil(), X)) -> mark(X),
                                                                    active(and(tt(), X)) -> mark(X),
                                                                     active(isNeList(V)) -> mark(isQid(V)),
                                                            active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                            active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                       active(isList(V)) -> mark(isNeList(V)),
                                                              active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                                   active(isList(nil())) -> mark(tt()),
                                                                      active(isQid(a())) -> mark(tt()),
                                                                      active(isQid(e())) -> mark(tt()),
                                                                      active(isQid(i())) -> mark(tt()),
                                                                      active(isQid(o())) -> mark(tt()),
                                                                      active(isQid(u())) -> mark(tt()),
                                                                      active(isNePal(V)) -> mark(isQid(V)),
                                                        active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                        active(isPal(V)) -> mark(isNePal(V)),
                                                                    active(isPal(nil())) -> mark(tt()),
                                                                       and(X1, mark(X2)) -> and(X1, X2),
                                                                     and(X1, active(X2)) -> and(X1, X2),
                                                                       and(mark(X1), X2) -> and(X1, X2),
                                                                     and(active(X1), X2) -> and(X1, X2),
                                                                       isNeList(mark(X)) -> isNeList(X),
                                                                     isNeList(active(X)) -> isNeList(X),
                                                                         isList(mark(X)) -> isList(X),
                                                                       isList(active(X)) -> isList(X),
                                                                          isQid(mark(X)) -> isQid(X),
                                                                        isQid(active(X)) -> isQid(X),
                                                                        isNePal(mark(X)) -> isNePal(X),
                                                                      isNePal(active(X)) -> isNePal(X),
                                                                          isPal(mark(X)) -> isPal(X),
                                                                        isPal(active(X)) -> isPal(X)}
                                                      EDG:
                                                       {(active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                        (active#(isNeList(V)) -> mark#(isQid(V)), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))
                                                        (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(isNeList(V)) -> mark#(isQid(V)))}
                                                       SCCS:
                                                        Scc:
                                                         {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                          active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                              active#(isNeList(V)) -> mark#(isQid(V))}
                                                        SCC:
                                                         Strict:
                                                          {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                           active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))),
                                                               active#(isNeList(V)) -> mark#(isQid(V))}
                                                         Weak:
                                                         {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                               mark(nil()) -> active(nil()),
                                                                         mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                                mark(tt()) -> active(tt()),
                                                                         mark(isNeList(X)) -> active(isNeList(X)),
                                                                           mark(isList(X)) -> active(isList(X)),
                                                                            mark(isQid(X)) -> active(isQid(X)),
                                                                          mark(isNePal(X)) -> active(isNePal(X)),
                                                                            mark(isPal(X)) -> active(isPal(X)),
                                                                                 mark(a()) -> active(a()),
                                                                                 mark(e()) -> active(e()),
                                                                                 mark(i()) -> active(i()),
                                                                                 mark(o()) -> active(o()),
                                                                                 mark(u()) -> active(u()),
                                                                          __(X1, mark(X2)) -> __(X1, X2),
                                                                        __(X1, active(X2)) -> __(X1, X2),
                                                                          __(mark(X1), X2) -> __(X1, X2),
                                                                        __(active(X1), X2) -> __(X1, X2),
                                                                      active(__(X, nil())) -> mark(X),
                                                                   active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                                      active(__(nil(), X)) -> mark(X),
                                                                      active(and(tt(), X)) -> mark(X),
                                                                       active(isNeList(V)) -> mark(isQid(V)),
                                                              active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                              active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                         active(isList(V)) -> mark(isNeList(V)),
                                                                active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                                     active(isList(nil())) -> mark(tt()),
                                                                        active(isQid(a())) -> mark(tt()),
                                                                        active(isQid(e())) -> mark(tt()),
                                                                        active(isQid(i())) -> mark(tt()),
                                                                        active(isQid(o())) -> mark(tt()),
                                                                        active(isQid(u())) -> mark(tt()),
                                                                        active(isNePal(V)) -> mark(isQid(V)),
                                                          active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                          active(isPal(V)) -> mark(isNePal(V)),
                                                                      active(isPal(nil())) -> mark(tt()),
                                                                         and(X1, mark(X2)) -> and(X1, X2),
                                                                       and(X1, active(X2)) -> and(X1, X2),
                                                                         and(mark(X1), X2) -> and(X1, X2),
                                                                       and(active(X1), X2) -> and(X1, X2),
                                                                         isNeList(mark(X)) -> isNeList(X),
                                                                       isNeList(active(X)) -> isNeList(X),
                                                                           isList(mark(X)) -> isList(X),
                                                                         isList(active(X)) -> isList(X),
                                                                            isQid(mark(X)) -> isQid(X),
                                                                          isQid(active(X)) -> isQid(X),
                                                                          isNePal(mark(X)) -> isNePal(X),
                                                                        isNePal(active(X)) -> isNePal(X),
                                                                            isPal(mark(X)) -> isPal(X),
                                                                          isPal(active(X)) -> isPal(X)}
                                                         POLY:
                                                          Argument Filtering:
                                                           pi(u) = [], pi(o) = [], pi(i) = [], pi(e) = [], pi(a) = [], pi(isPal) = [], pi(isNePal) = [], pi(isQid) = [], pi(isList) = [], pi(isNeList) = [], pi(tt) = [], pi(and) = [], pi(nil) = [], pi(active#) = [], pi(active) = [], pi(__) = [], pi(mark#) = 0, pi(mark) = []
                                                          Usable Rules:
                                                           {}
                                                          Interpretation:
                                                           [active#] = 1,
                                                           [__] = 1,
                                                           [isQid] = 0
                                                          Strict:
                                                           {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                            active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z)))}
                                                          Weak:
                                                           {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                                 mark(nil()) -> active(nil()),
                                                                           mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                                  mark(tt()) -> active(tt()),
                                                                           mark(isNeList(X)) -> active(isNeList(X)),
                                                                             mark(isList(X)) -> active(isList(X)),
                                                                              mark(isQid(X)) -> active(isQid(X)),
                                                                            mark(isNePal(X)) -> active(isNePal(X)),
                                                                              mark(isPal(X)) -> active(isPal(X)),
                                                                                   mark(a()) -> active(a()),
                                                                                   mark(e()) -> active(e()),
                                                                                   mark(i()) -> active(i()),
                                                                                   mark(o()) -> active(o()),
                                                                                   mark(u()) -> active(u()),
                                                                            __(X1, mark(X2)) -> __(X1, X2),
                                                                          __(X1, active(X2)) -> __(X1, X2),
                                                                            __(mark(X1), X2) -> __(X1, X2),
                                                                          __(active(X1), X2) -> __(X1, X2),
                                                                        active(__(X, nil())) -> mark(X),
                                                                     active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                                        active(__(nil(), X)) -> mark(X),
                                                                        active(and(tt(), X)) -> mark(X),
                                                                         active(isNeList(V)) -> mark(isQid(V)),
                                                                active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                                active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                           active(isList(V)) -> mark(isNeList(V)),
                                                                  active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                                       active(isList(nil())) -> mark(tt()),
                                                                          active(isQid(a())) -> mark(tt()),
                                                                          active(isQid(e())) -> mark(tt()),
                                                                          active(isQid(i())) -> mark(tt()),
                                                                          active(isQid(o())) -> mark(tt()),
                                                                          active(isQid(u())) -> mark(tt()),
                                                                          active(isNePal(V)) -> mark(isQid(V)),
                                                            active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                            active(isPal(V)) -> mark(isNePal(V)),
                                                                        active(isPal(nil())) -> mark(tt()),
                                                                           and(X1, mark(X2)) -> and(X1, X2),
                                                                         and(X1, active(X2)) -> and(X1, X2),
                                                                           and(mark(X1), X2) -> and(X1, X2),
                                                                         and(active(X1), X2) -> and(X1, X2),
                                                                           isNeList(mark(X)) -> isNeList(X),
                                                                         isNeList(active(X)) -> isNeList(X),
                                                                             isList(mark(X)) -> isList(X),
                                                                           isList(active(X)) -> isList(X),
                                                                              isQid(mark(X)) -> isQid(X),
                                                                            isQid(active(X)) -> isQid(X),
                                                                            isNePal(mark(X)) -> isNePal(X),
                                                                          isNePal(active(X)) -> isNePal(X),
                                                                              isPal(mark(X)) -> isPal(X),
                                                                            isPal(active(X)) -> isPal(X)}
                                                          EDG:
                                                           {(active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))), mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))))
                                                            (mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))), active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z))))}
                                                           SCCS:
                                                            Scc:
                                                             {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                              active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z)))}
                                                            SCC:
                                                             Strict:
                                                              {       mark#(__(X1, X2)) -> active#(__(mark(X1), mark(X2))),
                                                               active#(__(__(X, Y), Z)) -> mark#(__(X, __(Y, Z)))}
                                                             Weak:
                                                             {                mark(__(X1, X2)) -> active(__(mark(X1), mark(X2))),
                                                                                   mark(nil()) -> active(nil()),
                                                                             mark(and(X1, X2)) -> active(and(mark(X1), X2)),
                                                                                    mark(tt()) -> active(tt()),
                                                                             mark(isNeList(X)) -> active(isNeList(X)),
                                                                               mark(isList(X)) -> active(isList(X)),
                                                                                mark(isQid(X)) -> active(isQid(X)),
                                                                              mark(isNePal(X)) -> active(isNePal(X)),
                                                                                mark(isPal(X)) -> active(isPal(X)),
                                                                                     mark(a()) -> active(a()),
                                                                                     mark(e()) -> active(e()),
                                                                                     mark(i()) -> active(i()),
                                                                                     mark(o()) -> active(o()),
                                                                                     mark(u()) -> active(u()),
                                                                              __(X1, mark(X2)) -> __(X1, X2),
                                                                            __(X1, active(X2)) -> __(X1, X2),
                                                                              __(mark(X1), X2) -> __(X1, X2),
                                                                            __(active(X1), X2) -> __(X1, X2),
                                                                          active(__(X, nil())) -> mark(X),
                                                                       active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))),
                                                                          active(__(nil(), X)) -> mark(X),
                                                                          active(and(tt(), X)) -> mark(X),
                                                                           active(isNeList(V)) -> mark(isQid(V)),
                                                                  active(isNeList(__(V1, V2))) -> mark(and(isNeList(V1), isList(V2))),
                                                                  active(isNeList(__(V1, V2))) -> mark(and(isList(V1), isNeList(V2))),
                                                                             active(isList(V)) -> mark(isNeList(V)),
                                                                    active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2))),
                                                                         active(isList(nil())) -> mark(tt()),
                                                                            active(isQid(a())) -> mark(tt()),
                                                                            active(isQid(e())) -> mark(tt()),
                                                                            active(isQid(i())) -> mark(tt()),
                                                                            active(isQid(o())) -> mark(tt()),
                                                                            active(isQid(u())) -> mark(tt()),
                                                                            active(isNePal(V)) -> mark(isQid(V)),
                                                              active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P))),
                                                                              active(isPal(V)) -> mark(isNePal(V)),
                                                                          active(isPal(nil())) -> mark(tt()),
                                                                             and(X1, mark(X2)) -> and(X1, X2),
                                                                           and(X1, active(X2)) -> and(X1, X2),
                                                                             and(mark(X1), X2) -> and(X1, X2),
                                                                           and(active(X1), X2) -> and(X1, X2),
                                                                             isNeList(mark(X)) -> isNeList(X),
                                                                           isNeList(active(X)) -> isNeList(X),
                                                                               isList(mark(X)) -> isList(X),
                                                                             isList(active(X)) -> isList(X),
                                                                                isQid(mark(X)) -> isQid(X),
                                                                              isQid(active(X)) -> isQid(X),
                                                                              isNePal(mark(X)) -> isNePal(X),
                                                                            isNePal(active(X)) -> isNePal(X),
                                                                                isPal(mark(X)) -> isPal(X),
                                                                              isPal(active(X)) -> isPal(X)}
                                                             Fail