Problem Maude 06 PALINDROME complete

Tool IRC1

Execution TimeUnknown
Answer
MAYBE
InputMaude 06 PALINDROME complete

stdout:

MAYBE

Tool IRC2

Execution TimeUnknown
Answer
YES(?,O(n^1))
InputMaude 06 PALINDROME complete

stdout:

YES(?,O(n^1))

'Fastest (timeout of 60.0 seconds)'
-----------------------------------
Answer:           YES(?,O(n^1))
Input Problem:    innermost runtime-complexity with respect to
  Rules:
    {  __(__(X, Y), Z) -> __(X, __(Y, Z))
     , __(X, nil()) -> X
     , __(nil(), X) -> X
     , U11(tt(), V) -> U12(isNeList(V))
     , U12(tt()) -> tt()
     , U21(tt(), V1, V2) -> U22(isList(V1), V2)
     , U22(tt(), V2) -> U23(isList(V2))
     , U23(tt()) -> tt()
     , U31(tt(), V) -> U32(isQid(V))
     , U32(tt()) -> tt()
     , U41(tt(), V1, V2) -> U42(isList(V1), V2)
     , U42(tt(), V2) -> U43(isNeList(V2))
     , U43(tt()) -> tt()
     , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
     , U52(tt(), V2) -> U53(isList(V2))
     , U53(tt()) -> tt()
     , U61(tt(), V) -> U62(isQid(V))
     , U62(tt()) -> tt()
     , U71(tt(), V) -> U72(isNePal(V))
     , U72(tt()) -> tt()
     , and(tt(), X) -> X
     , isList(V) -> U11(isPalListKind(V), V)
     , isList(nil()) -> tt()
     , isList(__(V1, V2)) ->
       U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
     , isNeList(V) -> U31(isPalListKind(V), V)
     , isNeList(__(V1, V2)) ->
       U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
     , isNeList(__(V1, V2)) ->
       U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
     , isNePal(V) -> U61(isPalListKind(V), V)
     , isNePal(__(I, __(P, I))) ->
       and(and(isQid(I), isPalListKind(I)),
           and(isPal(P), isPalListKind(P)))
     , isPal(V) -> U71(isPalListKind(V), V)
     , isPal(nil()) -> tt()
     , isPalListKind(a()) -> tt()
     , isPalListKind(e()) -> tt()
     , isPalListKind(i()) -> tt()
     , isPalListKind(nil()) -> tt()
     , isPalListKind(o()) -> tt()
     , isPalListKind(u()) -> tt()
     , isPalListKind(__(V1, V2)) ->
       and(isPalListKind(V1), isPalListKind(V2))
     , isQid(a()) -> tt()
     , isQid(e()) -> tt()
     , isQid(i()) -> tt()
     , isQid(o()) -> tt()
     , isQid(u()) -> tt()}

Proof Output:    
  'wdg' proved the best result:
  
  Details:
  --------
    'wdg' succeeded with the following output:
     'wdg'
     -----
     Answer:           YES(?,O(n^1))
     Input Problem:    innermost runtime-complexity with respect to
       Rules:
         {  __(__(X, Y), Z) -> __(X, __(Y, Z))
          , __(X, nil()) -> X
          , __(nil(), X) -> X
          , U11(tt(), V) -> U12(isNeList(V))
          , U12(tt()) -> tt()
          , U21(tt(), V1, V2) -> U22(isList(V1), V2)
          , U22(tt(), V2) -> U23(isList(V2))
          , U23(tt()) -> tt()
          , U31(tt(), V) -> U32(isQid(V))
          , U32(tt()) -> tt()
          , U41(tt(), V1, V2) -> U42(isList(V1), V2)
          , U42(tt(), V2) -> U43(isNeList(V2))
          , U43(tt()) -> tt()
          , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
          , U52(tt(), V2) -> U53(isList(V2))
          , U53(tt()) -> tt()
          , U61(tt(), V) -> U62(isQid(V))
          , U62(tt()) -> tt()
          , U71(tt(), V) -> U72(isNePal(V))
          , U72(tt()) -> tt()
          , and(tt(), X) -> X
          , isList(V) -> U11(isPalListKind(V), V)
          , isList(nil()) -> tt()
          , isList(__(V1, V2)) ->
            U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
          , isNeList(V) -> U31(isPalListKind(V), V)
          , isNeList(__(V1, V2)) ->
            U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
          , isNeList(__(V1, V2)) ->
            U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
          , isNePal(V) -> U61(isPalListKind(V), V)
          , isNePal(__(I, __(P, I))) ->
            and(and(isQid(I), isPalListKind(I)),
                and(isPal(P), isPalListKind(P)))
          , isPal(V) -> U71(isPalListKind(V), V)
          , isPal(nil()) -> tt()
          , isPalListKind(a()) -> tt()
          , isPalListKind(e()) -> tt()
          , isPalListKind(i()) -> tt()
          , isPalListKind(nil()) -> tt()
          , isPalListKind(o()) -> tt()
          , isPalListKind(u()) -> tt()
          , isPalListKind(__(V1, V2)) ->
            and(isPalListKind(V1), isPalListKind(V2))
          , isQid(a()) -> tt()
          , isQid(e()) -> tt()
          , isQid(i()) -> tt()
          , isQid(o()) -> tt()
          , isQid(u()) -> tt()}
     
     Proof Output:    
       Transformation Details:
       -----------------------
         We have computed the following set of weak (innermost) dependency pairs:
         
           {  1: __^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))
            , 2: __^#(X, nil()) -> c_1()
            , 3: __^#(nil(), X) -> c_2()
            , 4: U11^#(tt(), V) -> c_3(U12^#(isNeList(V)))
            , 5: U12^#(tt()) -> c_4()
            , 6: U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))
            , 7: U22^#(tt(), V2) -> c_6(U23^#(isList(V2)))
            , 8: U23^#(tt()) -> c_7()
            , 9: U31^#(tt(), V) -> c_8(U32^#(isQid(V)))
            , 10: U32^#(tt()) -> c_9()
            , 11: U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))
            , 12: U42^#(tt(), V2) -> c_11(U43^#(isNeList(V2)))
            , 13: U43^#(tt()) -> c_12()
            , 14: U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))
            , 15: U52^#(tt(), V2) -> c_14(U53^#(isList(V2)))
            , 16: U53^#(tt()) -> c_15()
            , 17: U61^#(tt(), V) -> c_16(U62^#(isQid(V)))
            , 18: U62^#(tt()) -> c_17()
            , 19: U71^#(tt(), V) -> c_18(U72^#(isNePal(V)))
            , 20: U72^#(tt()) -> c_19()
            , 21: and^#(tt(), X) -> c_20()
            , 22: isList^#(V) -> c_21(U11^#(isPalListKind(V), V))
            , 23: isList^#(nil()) -> c_22()
            , 24: isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
            , 25: isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))
            , 26: isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
            , 27: isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
            , 28: isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))
            , 29: isNePal^#(__(I, __(P, I))) ->
                  c_28(and^#(and(isQid(I), isPalListKind(I)),
                             and(isPal(P), isPalListKind(P))))
            , 30: isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))
            , 31: isPal^#(nil()) -> c_30()
            , 32: isPalListKind^#(a()) -> c_31()
            , 33: isPalListKind^#(e()) -> c_32()
            , 34: isPalListKind^#(i()) -> c_33()
            , 35: isPalListKind^#(nil()) -> c_34()
            , 36: isPalListKind^#(o()) -> c_35()
            , 37: isPalListKind^#(u()) -> c_36()
            , 38: isPalListKind^#(__(V1, V2)) ->
                  c_37(and^#(isPalListKind(V1), isPalListKind(V2)))
            , 39: isQid^#(a()) -> c_38()
            , 40: isQid^#(e()) -> c_39()
            , 41: isQid^#(i()) -> c_40()
            , 42: isQid^#(o()) -> c_41()
            , 43: isQid^#(u()) -> c_42()}
         
         Following Dependency Graph (modulo SCCs) was computed. (Answers to
         subproofs are indicated to the right.)
         
           ->{43}                                                      [    YES(?,O(1))     ]
           
           ->{42}                                                      [    YES(?,O(1))     ]
           
           ->{41}                                                      [    YES(?,O(1))     ]
           
           ->{40}                                                      [    YES(?,O(1))     ]
           
           ->{39}                                                      [    YES(?,O(1))     ]
           
           ->{38}                                                      [    YES(?,O(1))     ]
              |
              `->{21}                                                  [    YES(?,O(1))     ]
           
           ->{37}                                                      [    YES(?,O(1))     ]
           
           ->{36}                                                      [    YES(?,O(1))     ]
           
           ->{35}                                                      [    YES(?,O(1))     ]
           
           ->{34}                                                      [    YES(?,O(1))     ]
           
           ->{33}                                                      [    YES(?,O(1))     ]
           
           ->{32}                                                      [    YES(?,O(1))     ]
           
           ->{31}                                                      [    YES(?,O(1))     ]
           
           ->{30}                                                      [    YES(?,O(1))     ]
              |
              `->{19}                                                  [    YES(?,O(1))     ]
                  |
                  `->{20}                                              [    YES(?,O(1))     ]
           
           ->{29}                                                      [    YES(?,O(1))     ]
              |
              `->{21}                                                  [    YES(?,O(1))     ]
           
           ->{28}                                                      [    YES(?,O(1))     ]
              |
              `->{17}                                                  [    YES(?,O(1))     ]
                  |
                  `->{18}                                              [    YES(?,O(1))     ]
           
           ->{27}                                                      [    YES(?,O(1))     ]
              |
              `->{14}                                                  [    YES(?,O(1))     ]
                  |
                  `->{15}                                              [    YES(?,O(1))     ]
                      |
                      `->{16}                                          [    YES(?,O(1))     ]
           
           ->{26}                                                      [    YES(?,O(1))     ]
              |
              `->{11}                                                  [    YES(?,O(1))     ]
                  |
                  `->{12}                                              [    YES(?,O(1))     ]
                      |
                      `->{13}                                          [    YES(?,O(1))     ]
           
           ->{25}                                                      [    YES(?,O(1))     ]
              |
              `->{9}                                                   [    YES(?,O(1))     ]
                  |
                  `->{10}                                              [    YES(?,O(1))     ]
           
           ->{24}                                                      [    YES(?,O(1))     ]
              |
              `->{6}                                                   [    YES(?,O(1))     ]
                  |
                  `->{7}                                               [    YES(?,O(1))     ]
                      |
                      `->{8}                                           [    YES(?,O(1))     ]
           
           ->{23}                                                      [    YES(?,O(1))     ]
           
           ->{22}                                                      [    YES(?,O(1))     ]
              |
              `->{4}                                                   [    YES(?,O(1))     ]
                  |
                  `->{5}                                               [    YES(?,O(1))     ]
           
           ->{1}                                                       [    YES(?,O(1))     ]
              |
              |->{2}                                                   [    YES(?,O(1))     ]
              |
              `->{3}                                                   [    YES(?,O(1))     ]
           
         
       
       Sub-problems:
       -------------
         * Path {1}: YES(?,O(1))
           ---------------------
           
           The usable rules for this path are:
           
             {  __(__(X, Y), Z) -> __(X, __(Y, Z))
              , __(X, nil()) -> X
              , __(nil(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {2}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {2},
               Uargs(c_0) = {1}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [1] x2 + [1]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [3] x1 + [1] x2 + [0]
              c_0(x1) = [1] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {__^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))}
             Weak Rules:
               {  __(__(X, Y), Z) -> __(X, __(Y, Z))
                , __(X, nil()) -> X
                , __(nil(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(__^#) = {}, Uargs(c_0) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [1] x2 + [1]
              nil() = [7]
              __^#(x1, x2) = [4] x1 + [0] x2 + [0]
              c_0(x1) = [2] x1 + [3]
         
         * Path {1}->{2}: YES(?,O(1))
           --------------------------
           
           The usable rules for this path are:
           
             {  __(__(X, Y), Z) -> __(X, __(Y, Z))
              , __(X, nil()) -> X
              , __(nil(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {2}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {2},
               Uargs(c_0) = {1}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [1] x2 + [2]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [3] x2 + [0]
              c_0(x1) = [1] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {__^#(X, nil()) -> c_1()}
             Weak Rules:
               {  __^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))
                , __(__(X, Y), Z) -> __(X, __(Y, Z))
                , __(X, nil()) -> X
                , __(nil(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(__^#) = {}, Uargs(c_0) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [1] x2 + [0]
              nil() = [2]
              __^#(x1, x2) = [4] x1 + [3] x2 + [2]
              c_0(x1) = [1] x1 + [0]
              c_1() = [1]
         
         * Path {1}->{3}: YES(?,O(1))
           --------------------------
           
           The usable rules for this path are:
           
             {  __(__(X, Y), Z) -> __(X, __(Y, Z))
              , __(X, nil()) -> X
              , __(nil(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {2}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {2},
               Uargs(c_0) = {1}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [1] x2 + [2]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [3] x2 + [0]
              c_0(x1) = [1] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {__^#(nil(), X) -> c_2()}
             Weak Rules:
               {  __^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))
                , __(__(X, Y), Z) -> __(X, __(Y, Z))
                , __(X, nil()) -> X
                , __(nil(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(__^#) = {}, Uargs(c_0) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [1] x2 + [2]
              nil() = [2]
              __^#(x1, x2) = [2] x1 + [0] x2 + [4]
              c_0(x1) = [2] x1 + [0]
              c_2() = [1]
         
         * Path {22}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {1}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {1}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [3] x1 + [0]
              c_21(x1) = [1] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isList^#(V) -> c_21(U11^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U11^#) = {}, Uargs(isList^#) = {}, Uargs(c_21) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U11^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isList^#(x1) = [7] x1 + [7]
              c_21(x1) = [2] x1 + [3]
         
         * Path {22}->{4}: YES(?,O(1))
           ---------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {1}, Uargs(c_3) = {1},
               Uargs(U12^#) = {1}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {1}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [3]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [2] x1 + [0] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [0] x1 + [3]
              U41(x1, x2, x3) = [2] x1 + [3] x2 + [2] x3 + [2]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_3(x1) = [1] x1 + [0]
              U12^#(x1) = [1] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [1] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U11^#(tt(), V) -> c_3(U12^#(isNeList(V)))}
             Weak Rules:
               {  isList^#(V) -> c_21(U11^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {1}, Uargs(U12^#) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [0] x2 + [0]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [4] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [0]
              U11^#(x1, x2) = [0] x1 + [4] x2 + [4]
              c_3(x1) = [2] x1 + [3]
              U12^#(x1) = [2] x1 + [0]
              isList^#(x1) = [7] x1 + [7]
              c_21(x1) = [1] x1 + [3]
         
         * Path {22}->{4}->{5}: YES(?,O(1))
           --------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {1}, Uargs(c_3) = {1},
               Uargs(U12^#) = {1}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {1}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [3]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [1]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [1] x1 + [2] x2 + [3] x3 + [3]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [1]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_3(x1) = [1] x1 + [0]
              U12^#(x1) = [3] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [1] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U12^#(tt()) -> c_4()}
             Weak Rules:
               {  U11^#(tt(), V) -> c_3(U12^#(isNeList(V)))
                , isList^#(V) -> c_21(U11^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {1}, Uargs(U12^#) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [0] x2 + [2]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [1] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [1] x2 + [0] x3 + [4]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [4] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [1] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [3] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [0]
              o() = [0]
              u() = [2]
              U11^#(x1, x2) = [0] x1 + [4] x2 + [4]
              c_3(x1) = [2] x1 + [0]
              U12^#(x1) = [2] x1 + [1]
              c_4() = [0]
              isList^#(x1) = [7] x1 + [7]
              c_21(x1) = [1] x1 + [3]
         
         * Path {23}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isList^#(nil()) -> c_22()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isList^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              nil() = [7]
              isList^#(x1) = [1] x1 + [7]
              c_22() = [1]
         
         * Path {24}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {1}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [3] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules:
               {isList^#(__(V1, V2)) ->
                c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(isList^#) = {}, Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [2]
              u() = [2]
              U21^#(x1, x2, x3) = [1] x1 + [0] x2 + [0] x3 + [0]
              isList^#(x1) = [2] x1 + [1]
              c_23(x1) = [2] x1 + [3]
         
         * Path {24}->{6}: YES(?,O(1))
           ---------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {1}, Uargs(c_5) = {1},
               Uargs(U22^#) = {1}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [1] x2 + [1]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              c_5(x1) = [1] x1 + [0]
              U22^#(x1, x2) = [1] x1 + [3] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))}
             Weak Rules:
               {  isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {1}, Uargs(U22^#) = {},
               Uargs(isList^#) = {}, Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [2]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [6] x1 + [0]
              U21(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [2] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [2] x1 + [5] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U21^#(x1, x2, x3) = [3] x1 + [2] x2 + [0] x3 + [2]
              c_5(x1) = [4] x1 + [1]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              isList^#(x1) = [3] x1 + [4]
              c_23(x1) = [2] x1 + [3]
         
         * Path {24}->{6}->{7}: YES(?,O(1))
           --------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {1}, Uargs(c_5) = {1},
               Uargs(U22^#) = {1}, Uargs(c_6) = {1}, Uargs(U23^#) = {1},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [3] x3 + [3]
              U42(x1, x2) = [1] x1 + [3] x2 + [2]
              U43(x1) = [1] x1 + [2]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [1]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [1] x1 + [0]
              U22^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_6(x1) = [1] x1 + [0]
              U23^#(x1) = [1] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U22^#(tt(), V2) -> c_6(U23^#(isList(V2)))}
             Weak Rules:
               {  U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))
                , isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {1}, Uargs(U22^#) = {},
               Uargs(c_6) = {1}, Uargs(U23^#) = {}, Uargs(isList^#) = {},
               Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [4] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [4] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [4] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [5] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [4] x3 + [4]
              c_5(x1) = [1] x1 + [1]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [2]
              c_6(x1) = [2] x1 + [1]
              U23^#(x1) = [2] x1 + [0]
              isList^#(x1) = [4] x1 + [7]
              c_23(x1) = [1] x1 + [3]
         
         * Path {24}->{6}->{7}->{8}: YES(?,O(1))
           -------------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {1}, Uargs(c_5) = {1},
               Uargs(U22^#) = {1}, Uargs(c_6) = {1}, Uargs(U23^#) = {1},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [2] x1 + [0] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [0] x1 + [3]
              U41(x1, x2, x3) = [3] x1 + [3] x2 + [2] x3 + [0]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [1] x1 + [0]
              U22^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_6(x1) = [1] x1 + [0]
              U23^#(x1) = [3] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U23^#(tt()) -> c_7()}
             Weak Rules:
               {  U22^#(tt(), V2) -> c_6(U23^#(isList(V2)))
                , U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))
                , isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {1}, Uargs(U22^#) = {},
               Uargs(c_6) = {1}, Uargs(U23^#) = {}, Uargs(isList^#) = {},
               Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [6] x2 + [4]
              nil() = [3]
              U11(x1, x2) = [2] x1 + [0] x2 + [0]
              tt() = [3]
              U12(x1) = [0] x1 + [3]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [4] x1 + [1] x2 + [6] x3 + [0]
              U22(x1, x2) = [0] x1 + [6] x2 + [0]
              isList(x1) = [2] x1 + [0]
              U23(x1) = [3] x1 + [0]
              U31(x1, x2) = [2] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [3]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [4] x2 + [4] x3 + [4]
              U42(x1, x2) = [2] x1 + [4] x2 + [0]
              U43(x1) = [2] x1 + [0]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [6] x3 + [0]
              U52(x1, x2) = [2] x1 + [6] x2 + [0]
              U53(x1) = [2] x1 + [0]
              and(x1, x2) = [0] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              a() = [4]
              e() = [6]
              i() = [4]
              o() = [6]
              u() = [4]
              U21^#(x1, x2, x3) = [2] x1 + [0] x2 + [4] x3 + [2]
              c_5(x1) = [1] x1 + [5]
              U22^#(x1, x2) = [0] x1 + [4] x2 + [2]
              c_6(x1) = [1] x1 + [0]
              U23^#(x1) = [2] x1 + [2]
              c_7() = [1]
              isList^#(x1) = [2] x1 + [7]
              c_23(x1) = [2] x1 + [3]
         
         * Path {25}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {1}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {1}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [3] x1 + [0]
              c_24(x1) = [1] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U31^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_24) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U31^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isNeList^#(x1) = [7] x1 + [7]
              c_24(x1) = [2] x1 + [3]
         
         * Path {25}->{9}: YES(?,O(1))
           ---------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {1}, Uargs(c_8) = {1}, Uargs(U32^#) = {1},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {1}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_8(x1) = [1] x1 + [0]
              U32^#(x1) = [1] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [1] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U31^#(tt(), V) -> c_8(U32^#(isQid(V)))}
             Weak Rules:
               {  isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {1},
               Uargs(U32^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_24) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_8(x1) = [2] x1 + [0]
              U32^#(x1) = [2] x1 + [0]
              isNeList^#(x1) = [7] x1 + [7]
              c_24(x1) = [4] x1 + [3]
         
         * Path {25}->{9}->{10}: YES(?,O(1))
           ---------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {1}, Uargs(c_8) = {1}, Uargs(U32^#) = {1},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {1}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_8(x1) = [1] x1 + [0]
              U32^#(x1) = [3] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [1] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U32^#(tt()) -> c_9()}
             Weak Rules:
               {  U31^#(tt(), V) -> c_8(U32^#(isQid(V)))
                , isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {1},
               Uargs(U32^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_24) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [2] x2 + [6]
              nil() = [0]
              tt() = [3]
              isQid(x1) = [1] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [3]
              a() = [3]
              e() = [6]
              i() = [3]
              o() = [3]
              u() = [3]
              U31^#(x1, x2) = [2] x1 + [4] x2 + [0]
              c_8(x1) = [2] x1 + [2]
              U32^#(x1) = [2] x1 + [2]
              c_9() = [1]
              isNeList^#(x1) = [7] x1 + [7]
              c_24(x1) = [1] x1 + [1]
         
         * Path {26}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {1}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [3] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules:
               {isNeList^#(__(V1, V2)) ->
                c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [2]
              u() = [2]
              U41^#(x1, x2, x3) = [1] x1 + [0] x2 + [0] x3 + [0]
              isNeList^#(x1) = [2] x1 + [1]
              c_25(x1) = [2] x1 + [3]
         
         * Path {26}->{11}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {1}, Uargs(c_10) = {1}, Uargs(U42^#) = {1},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [1] x2 + [1]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [1] x1 + [3] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))}
             Weak Rules:
               {  isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {1}, Uargs(U42^#) = {},
               Uargs(isNeList^#) = {}, Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [2]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [6] x1 + [0]
              U21(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [2] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [2] x1 + [5] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U41^#(x1, x2, x3) = [3] x1 + [2] x2 + [0] x3 + [2]
              c_10(x1) = [4] x1 + [1]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              isNeList^#(x1) = [3] x1 + [4]
              c_25(x1) = [2] x1 + [3]
         
         * Path {26}->{11}->{12}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {1}, Uargs(c_10) = {1}, Uargs(U42^#) = {1},
               Uargs(c_11) = {1}, Uargs(U43^#) = {1}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [3] x3 + [3]
              U42(x1, x2) = [1] x1 + [3] x2 + [2]
              U43(x1) = [1] x1 + [2]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [1]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_11(x1) = [1] x1 + [0]
              U43^#(x1) = [1] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U42^#(tt(), V2) -> c_11(U43^#(isNeList(V2)))}
             Weak Rules:
               {  U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {1}, Uargs(U42^#) = {},
               Uargs(c_11) = {1}, Uargs(U43^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [6] x2 + [4]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [6] x3 + [4]
              c_10(x1) = [2] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [2]
              c_11(x1) = [2] x1 + [1]
              U43^#(x1) = [2] x1 + [0]
              isNeList^#(x1) = [2] x1 + [7]
              c_25(x1) = [2] x1 + [7]
         
         * Path {26}->{11}->{12}->{13}: YES(?,O(1))
           ----------------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {1}, Uargs(c_10) = {1}, Uargs(U42^#) = {1},
               Uargs(c_11) = {1}, Uargs(U43^#) = {1}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [2] x1 + [0] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [0] x1 + [3]
              U41(x1, x2, x3) = [3] x1 + [3] x2 + [2] x3 + [0]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_11(x1) = [1] x1 + [0]
              U43^#(x1) = [3] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U43^#(tt()) -> c_12()}
             Weak Rules:
               {  U42^#(tt(), V2) -> c_11(U43^#(isNeList(V2)))
                , U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {1}, Uargs(U42^#) = {},
               Uargs(c_11) = {1}, Uargs(U43^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [6] x2 + [6]
              nil() = [6]
              U11(x1, x2) = [0] x1 + [0] x2 + [4]
              tt() = [3]
              U12(x1) = [0] x1 + [3]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [3]
              U22(x1, x2) = [0] x1 + [0] x2 + [3]
              isList(x1) = [1] x1 + [4]
              U23(x1) = [0] x1 + [3]
              U31(x1, x2) = [0] x1 + [2] x2 + [2]
              U32(x1) = [1] x1 + [0]
              isQid(x1) = [2] x1 + [1]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [2] x3 + [4]
              U42(x1, x2) = [0] x1 + [2] x2 + [3]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [2] x3 + [2]
              U52(x1, x2) = [0] x1 + [2] x2 + [4]
              U53(x1) = [0] x1 + [4]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [3]
              a() = [1]
              e() = [2]
              i() = [2]
              o() = [1]
              u() = [4]
              U41^#(x1, x2, x3) = [2] x1 + [0] x2 + [4] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [4] x2 + [6]
              c_11(x1) = [1] x1 + [0]
              U43^#(x1) = [2] x1 + [2]
              c_12() = [1]
              isNeList^#(x1) = [2] x1 + [3]
              c_25(x1) = [2] x1 + [3]
         
         * Path {27}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {1},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [3] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules:
               {isNeList^#(__(V1, V2)) ->
                c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [2]
              u() = [2]
              U51^#(x1, x2, x3) = [1] x1 + [0] x2 + [0] x3 + [0]
              isNeList^#(x1) = [2] x1 + [1]
              c_26(x1) = [2] x1 + [3]
         
         * Path {27}->{14}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {1},
               Uargs(c_13) = {1}, Uargs(U52^#) = {1}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [1]
              U41(x1, x2, x3) = [3] x1 + [3] x2 + [2] x3 + [1]
              U42(x1, x2) = [1] x1 + [2] x2 + [3]
              U43(x1) = [1] x1 + [2]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [1] x1 + [3] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules:
               {U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))}
             Weak Rules:
               {  isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {1}, Uargs(U52^#) = {},
               Uargs(isNeList^#) = {}, Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [4]
              U11(x1, x2) = [0] x1 + [0] x2 + [3]
              tt() = [3]
              U12(x1) = [0] x1 + [3]
              isNeList(x1) = [6] x1 + [1]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [3]
              U22(x1, x2) = [0] x1 + [0] x2 + [3]
              isList(x1) = [0] x1 + [3]
              U23(x1) = [0] x1 + [3]
              U31(x1, x2) = [1] x1 + [4] x2 + [1]
              U32(x1) = [3] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [3] x1 + [0] x2 + [2] x3 + [4]
              U42(x1, x2) = [2] x1 + [0] x2 + [2]
              U43(x1) = [0] x1 + [4]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [4]
              U52(x1, x2) = [0] x1 + [0] x2 + [3]
              U53(x1) = [0] x1 + [3]
              and(x1, x2) = [0] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              a() = [4]
              e() = [4]
              i() = [3]
              o() = [3]
              u() = [3]
              U51^#(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [2]
              c_13(x1) = [1] x1 + [7]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              isNeList^#(x1) = [3] x1 + [7]
              c_26(x1) = [2] x1 + [1]
         
         * Path {27}->{14}->{15}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {1},
               Uargs(c_13) = {1}, Uargs(U52^#) = {1}, Uargs(c_14) = {1},
               Uargs(U53^#) = {1}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [2]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_14(x1) = [1] x1 + [0]
              U53^#(x1) = [1] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U52^#(tt(), V2) -> c_14(U53^#(isList(V2)))}
             Weak Rules:
               {  U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {1}, Uargs(U52^#) = {},
               Uargs(c_14) = {1}, Uargs(U53^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [4] x1 + [4] x2 + [4]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [1] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [4]
              U41(x1, x2, x3) = [0] x1 + [4] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [1] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [0] x1 + [4]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [2] x3 + [5]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [5]
              c_14(x1) = [2] x1 + [0]
              U53^#(x1) = [2] x1 + [2]
              isNeList^#(x1) = [2] x1 + [7]
              c_26(x1) = [2] x1 + [1]
         
         * Path {27}->{14}->{15}->{16}: YES(?,O(1))
           ----------------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {1},
               Uargs(c_13) = {1}, Uargs(U52^#) = {1}, Uargs(c_14) = {1},
               Uargs(U53^#) = {1}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [3] x3 + [2]
              U42(x1, x2) = [1] x1 + [3] x2 + [1]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_14(x1) = [1] x1 + [0]
              U53^#(x1) = [3] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U53^#(tt()) -> c_15()}
             Weak Rules:
               {  U52^#(tt(), V2) -> c_14(U53^#(isList(V2)))
                , U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {1}, Uargs(U52^#) = {},
               Uargs(c_14) = {1}, Uargs(U53^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [1] x2 + [0]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [1] x2 + [0]
              tt() = [2]
              U12(x1) = [1] x1 + [0]
              isNeList(x1) = [1] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [1] x2 + [1] x3 + [1]
              U22(x1, x2) = [0] x1 + [1] x2 + [1]
              isList(x1) = [1] x1 + [1]
              U23(x1) = [1] x1 + [0]
              U31(x1, x2) = [0] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [2] x2 + [1] x3 + [0]
              U42(x1, x2) = [0] x1 + [1] x2 + [0]
              U43(x1) = [1] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [2] x2 + [0] x3 + [0]
              U52(x1, x2) = [2] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [4]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [0] x1 + [2]
              a() = [4]
              e() = [4]
              i() = [2]
              o() = [4]
              u() = [2]
              U51^#(x1, x2, x3) = [0] x1 + [6] x2 + [4] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [6] x1 + [4] x2 + [0]
              c_14(x1) = [2] x1 + [0]
              U53^#(x1) = [2] x1 + [4]
              c_15() = [1]
              isNeList^#(x1) = [4] x1 + [7]
              c_26(x1) = [1] x1 + [3]
         
         * Path {28}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {1}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {1}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [3] x1 + [0]
              c_27(x1) = [1] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U61^#) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U61^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isNePal^#(x1) = [7] x1 + [7]
              c_27(x1) = [2] x1 + [3]
         
         * Path {28}->{17}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {1}, Uargs(c_16) = {1},
               Uargs(U62^#) = {1}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {1}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_16(x1) = [1] x1 + [0]
              U62^#(x1) = [1] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [1] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U61^#(tt(), V) -> c_16(U62^#(isQid(V)))}
             Weak Rules:
               {  isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {1},
               Uargs(U62^#) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_16(x1) = [2] x1 + [0]
              U62^#(x1) = [2] x1 + [0]
              isNePal^#(x1) = [7] x1 + [7]
              c_27(x1) = [4] x1 + [3]
         
         * Path {28}->{17}->{18}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {1}, Uargs(c_16) = {1},
               Uargs(U62^#) = {1}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {1}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_16(x1) = [1] x1 + [0]
              U62^#(x1) = [3] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [1] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U62^#(tt()) -> c_17()}
             Weak Rules:
               {  U61^#(tt(), V) -> c_16(U62^#(isQid(V)))
                , isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {1},
               Uargs(U62^#) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [2] x2 + [6]
              nil() = [0]
              tt() = [3]
              isQid(x1) = [1] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [3]
              a() = [3]
              e() = [6]
              i() = [3]
              o() = [3]
              u() = [3]
              U61^#(x1, x2) = [2] x1 + [4] x2 + [0]
              c_16(x1) = [2] x1 + [2]
              U62^#(x1) = [2] x1 + [2]
              c_17() = [1]
              isNePal^#(x1) = [7] x1 + [7]
              c_27(x1) = [1] x1 + [1]
         
         * Path {29}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , U62(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(U11^#) = {},
               Uargs(c_3) = {}, Uargs(U12^#) = {}, Uargs(U21^#) = {},
               Uargs(c_5) = {}, Uargs(U22^#) = {}, Uargs(c_6) = {},
               Uargs(U23^#) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {},
               Uargs(U32^#) = {}, Uargs(U41^#) = {}, Uargs(c_10) = {},
               Uargs(U42^#) = {}, Uargs(c_11) = {}, Uargs(U43^#) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {}, Uargs(U52^#) = {},
               Uargs(c_14) = {}, Uargs(U53^#) = {}, Uargs(U61^#) = {},
               Uargs(c_16) = {}, Uargs(U62^#) = {}, Uargs(U71^#) = {},
               Uargs(c_18) = {}, Uargs(U72^#) = {}, Uargs(and^#) = {1, 2},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {1}, Uargs(isPal^#) = {}, Uargs(c_29) = {},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [1]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [3] x1 + [2]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [2] x1 + [2] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [2] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [1] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules:
               {isNePal^#(__(I, __(P, I))) ->
                c_28(and^#(and(isQid(I), isPalListKind(I)),
                           and(isPal(P), isPalListKind(P))))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , U62(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(and^#) = {}, Uargs(isNePal^#) = {},
               Uargs(c_28) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [6] x1 + [1] x2 + [2]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [1] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [2] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              and^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isNePal^#(x1) = [2] x1 + [5]
              c_28(x1) = [2] x1 + [3]
         
         * Path {29}->{21}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , U62(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(U11^#) = {},
               Uargs(c_3) = {}, Uargs(U12^#) = {}, Uargs(U21^#) = {},
               Uargs(c_5) = {}, Uargs(U22^#) = {}, Uargs(c_6) = {},
               Uargs(U23^#) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {},
               Uargs(U32^#) = {}, Uargs(U41^#) = {}, Uargs(c_10) = {},
               Uargs(U42^#) = {}, Uargs(c_11) = {}, Uargs(U43^#) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {}, Uargs(U52^#) = {},
               Uargs(c_14) = {}, Uargs(U53^#) = {}, Uargs(U61^#) = {},
               Uargs(c_16) = {}, Uargs(U62^#) = {}, Uargs(U71^#) = {},
               Uargs(c_18) = {}, Uargs(U72^#) = {}, Uargs(and^#) = {1, 2},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {1}, Uargs(isPal^#) = {}, Uargs(c_29) = {},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [1]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [3] x1 + [2]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [1] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {and^#(tt(), X) -> c_20()}
             Weak Rules:
               {  isNePal^#(__(I, __(P, I))) ->
                  c_28(and^#(and(isQid(I), isPalListKind(I)),
                             and(isPal(P), isPalListKind(P))))
                , and(tt(), X) -> X
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , U62(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(and^#) = {}, Uargs(isNePal^#) = {},
               Uargs(c_28) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [6] x1 + [1] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [2] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [2] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [4]
              i() = [0]
              o() = [0]
              u() = [0]
              and^#(x1, x2) = [3] x1 + [2] x2 + [1]
              c_20() = [0]
              isNePal^#(x1) = [2] x1 + [6]
              c_28(x1) = [2] x1 + [1]
         
         * Path {30}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {1}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {1},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [3] x1 + [0]
              c_29(x1) = [1] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U71^#) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U71^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isPal^#(x1) = [7] x1 + [7]
              c_29(x1) = [2] x1 + [3]
         
         * Path {30}->{19}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U62(tt()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(U11^#) = {},
               Uargs(c_3) = {}, Uargs(U12^#) = {}, Uargs(U21^#) = {},
               Uargs(c_5) = {}, Uargs(U22^#) = {}, Uargs(c_6) = {},
               Uargs(U23^#) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {},
               Uargs(U32^#) = {}, Uargs(U41^#) = {}, Uargs(c_10) = {},
               Uargs(U42^#) = {}, Uargs(c_11) = {}, Uargs(U43^#) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {}, Uargs(U52^#) = {},
               Uargs(c_14) = {}, Uargs(U53^#) = {}, Uargs(U61^#) = {},
               Uargs(c_16) = {}, Uargs(U62^#) = {}, Uargs(U71^#) = {1},
               Uargs(c_18) = {1}, Uargs(U72^#) = {1}, Uargs(and^#) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [2] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [1]
              and(x1, x2) = [1] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [3] x1 + [2]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_18(x1) = [1] x1 + [0]
              U72^#(x1) = [1] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [1] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U71^#(tt(), V) -> c_18(U72^#(isNePal(V)))}
             Weak Rules:
               {  isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U62(tt()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {1},
               Uargs(U72^#) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_18(x1) = [2] x1 + [0]
              U72^#(x1) = [2] x1 + [0]
              isPal^#(x1) = [7] x1 + [7]
              c_29(x1) = [4] x1 + [3]
         
         * Path {30}->{19}->{20}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U62(tt()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(U11^#) = {},
               Uargs(c_3) = {}, Uargs(U12^#) = {}, Uargs(U21^#) = {},
               Uargs(c_5) = {}, Uargs(U22^#) = {}, Uargs(c_6) = {},
               Uargs(U23^#) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {},
               Uargs(U32^#) = {}, Uargs(U41^#) = {}, Uargs(c_10) = {},
               Uargs(U42^#) = {}, Uargs(c_11) = {}, Uargs(U43^#) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {}, Uargs(U52^#) = {},
               Uargs(c_14) = {}, Uargs(U53^#) = {}, Uargs(U61^#) = {},
               Uargs(c_16) = {}, Uargs(U62^#) = {}, Uargs(U71^#) = {1},
               Uargs(c_18) = {1}, Uargs(U72^#) = {1}, Uargs(and^#) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [3]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [1]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [2]
              and(x1, x2) = [1] x1 + [1] x2 + [1]
              isPalListKind(x1) = [1] x1 + [1]
              isPal(x1) = [3] x1 + [3]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_18(x1) = [1] x1 + [0]
              U72^#(x1) = [3] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [1] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {U72^#(tt()) -> c_19()}
             Weak Rules:
               {  U71^#(tt(), V) -> c_18(U72^#(isNePal(V)))
                , isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U62(tt()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {1},
               Uargs(U72^#) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [1] x2 + [4]
              nil() = [4]
              tt() = [2]
              isQid(x1) = [1] x1 + [0]
              U61(x1, x2) = [0] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [4]
              U72(x1) = [0] x1 + [4]
              isNePal(x1) = [1] x1 + [0]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [4]
              a() = [2]
              e() = [4]
              i() = [2]
              o() = [2]
              u() = [2]
              U71^#(x1, x2) = [0] x1 + [4] x2 + [4]
              c_18(x1) = [2] x1 + [3]
              U72^#(x1) = [2] x1 + [0]
              c_19() = [1]
              isPal^#(x1) = [7] x1 + [7]
              c_29(x1) = [1] x1 + [3]
         
         * Path {31}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPal^#(nil()) -> c_30()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPal^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              nil() = [7]
              isPal^#(x1) = [1] x1 + [7]
              c_30() = [1]
         
         * Path {32}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(a()) -> c_31()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              a() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_31() = [1]
         
         * Path {33}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(e()) -> c_32()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              e() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_32() = [1]
         
         * Path {34}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(i()) -> c_33()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              i() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_33() = [1]
         
         * Path {35}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(nil()) -> c_34()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              nil() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_34() = [1]
         
         * Path {36}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(o()) -> c_35()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              o() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_35() = [1]
         
         * Path {37}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(u()) -> c_36()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              u() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_36() = [1]
         
         * Path {38}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {1, 2}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {1}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [1] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [1] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules:
               {isPalListKind^#(__(V1, V2)) ->
                c_37(and^#(isPalListKind(V1), isPalListKind(V2)))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(and^#) = {}, Uargs(isPalListKind^#) = {}, Uargs(c_37) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [6] x1 + [2] x2 + [6]
              nil() = [2]
              tt() = [2]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [2]
              a() = [0]
              e() = [0]
              i() = [2]
              o() = [0]
              u() = [2]
              and^#(x1, x2) = [2] x1 + [0] x2 + [0]
              isPalListKind^#(x1) = [2] x1 + [3]
              c_37(x1) = [3] x1 + [1]
         
         * Path {38}->{21}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {1, 2}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {1}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [1] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {and^#(tt(), X) -> c_20()}
             Weak Rules:
               {  isPalListKind^#(__(V1, V2)) ->
                  c_37(and^#(isPalListKind(V1), isPalListKind(V2)))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(and^#) = {}, Uargs(isPalListKind^#) = {}, Uargs(c_37) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_20() = [0]
              isPalListKind^#(x1) = [0] x1 + [7]
              c_37(x1) = [4] x1 + [3]
         
         * Path {39}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isQid^#(a()) -> c_38()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              a() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_38() = [1]
         
         * Path {40}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isQid^#(e()) -> c_39()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              e() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_39() = [1]
         
         * Path {41}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isQid^#(i()) -> c_40()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              i() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_40() = [1]
         
         * Path {42}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isQid^#(o()) -> c_41()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              o() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_41() = [1]
         
         * Path {43}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1() = [0]
              c_2() = [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20() = [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    innermost DP runtime-complexity with respect to
             Strict Rules: {isQid^#(u()) -> c_42()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              u() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_42() = [1]

Tool RC1

Execution TimeUnknown
Answer
MAYBE
InputMaude 06 PALINDROME complete

stdout:

MAYBE

Tool RC2

Execution TimeUnknown
Answer
YES(?,O(n^1))
InputMaude 06 PALINDROME complete

stdout:

YES(?,O(n^1))

'Fastest (timeout of 60.0 seconds)'
-----------------------------------
Answer:           YES(?,O(n^1))
Input Problem:    runtime-complexity with respect to
  Rules:
    {  __(__(X, Y), Z) -> __(X, __(Y, Z))
     , __(X, nil()) -> X
     , __(nil(), X) -> X
     , U11(tt(), V) -> U12(isNeList(V))
     , U12(tt()) -> tt()
     , U21(tt(), V1, V2) -> U22(isList(V1), V2)
     , U22(tt(), V2) -> U23(isList(V2))
     , U23(tt()) -> tt()
     , U31(tt(), V) -> U32(isQid(V))
     , U32(tt()) -> tt()
     , U41(tt(), V1, V2) -> U42(isList(V1), V2)
     , U42(tt(), V2) -> U43(isNeList(V2))
     , U43(tt()) -> tt()
     , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
     , U52(tt(), V2) -> U53(isList(V2))
     , U53(tt()) -> tt()
     , U61(tt(), V) -> U62(isQid(V))
     , U62(tt()) -> tt()
     , U71(tt(), V) -> U72(isNePal(V))
     , U72(tt()) -> tt()
     , and(tt(), X) -> X
     , isList(V) -> U11(isPalListKind(V), V)
     , isList(nil()) -> tt()
     , isList(__(V1, V2)) ->
       U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
     , isNeList(V) -> U31(isPalListKind(V), V)
     , isNeList(__(V1, V2)) ->
       U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
     , isNeList(__(V1, V2)) ->
       U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
     , isNePal(V) -> U61(isPalListKind(V), V)
     , isNePal(__(I, __(P, I))) ->
       and(and(isQid(I), isPalListKind(I)),
           and(isPal(P), isPalListKind(P)))
     , isPal(V) -> U71(isPalListKind(V), V)
     , isPal(nil()) -> tt()
     , isPalListKind(a()) -> tt()
     , isPalListKind(e()) -> tt()
     , isPalListKind(i()) -> tt()
     , isPalListKind(nil()) -> tt()
     , isPalListKind(o()) -> tt()
     , isPalListKind(u()) -> tt()
     , isPalListKind(__(V1, V2)) ->
       and(isPalListKind(V1), isPalListKind(V2))
     , isQid(a()) -> tt()
     , isQid(e()) -> tt()
     , isQid(i()) -> tt()
     , isQid(o()) -> tt()
     , isQid(u()) -> tt()}

Proof Output:    
  'wdg' proved the best result:
  
  Details:
  --------
    'wdg' succeeded with the following output:
     'wdg'
     -----
     Answer:           YES(?,O(n^1))
     Input Problem:    runtime-complexity with respect to
       Rules:
         {  __(__(X, Y), Z) -> __(X, __(Y, Z))
          , __(X, nil()) -> X
          , __(nil(), X) -> X
          , U11(tt(), V) -> U12(isNeList(V))
          , U12(tt()) -> tt()
          , U21(tt(), V1, V2) -> U22(isList(V1), V2)
          , U22(tt(), V2) -> U23(isList(V2))
          , U23(tt()) -> tt()
          , U31(tt(), V) -> U32(isQid(V))
          , U32(tt()) -> tt()
          , U41(tt(), V1, V2) -> U42(isList(V1), V2)
          , U42(tt(), V2) -> U43(isNeList(V2))
          , U43(tt()) -> tt()
          , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
          , U52(tt(), V2) -> U53(isList(V2))
          , U53(tt()) -> tt()
          , U61(tt(), V) -> U62(isQid(V))
          , U62(tt()) -> tt()
          , U71(tt(), V) -> U72(isNePal(V))
          , U72(tt()) -> tt()
          , and(tt(), X) -> X
          , isList(V) -> U11(isPalListKind(V), V)
          , isList(nil()) -> tt()
          , isList(__(V1, V2)) ->
            U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
          , isNeList(V) -> U31(isPalListKind(V), V)
          , isNeList(__(V1, V2)) ->
            U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
          , isNeList(__(V1, V2)) ->
            U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
          , isNePal(V) -> U61(isPalListKind(V), V)
          , isNePal(__(I, __(P, I))) ->
            and(and(isQid(I), isPalListKind(I)),
                and(isPal(P), isPalListKind(P)))
          , isPal(V) -> U71(isPalListKind(V), V)
          , isPal(nil()) -> tt()
          , isPalListKind(a()) -> tt()
          , isPalListKind(e()) -> tt()
          , isPalListKind(i()) -> tt()
          , isPalListKind(nil()) -> tt()
          , isPalListKind(o()) -> tt()
          , isPalListKind(u()) -> tt()
          , isPalListKind(__(V1, V2)) ->
            and(isPalListKind(V1), isPalListKind(V2))
          , isQid(a()) -> tt()
          , isQid(e()) -> tt()
          , isQid(i()) -> tt()
          , isQid(o()) -> tt()
          , isQid(u()) -> tt()}
     
     Proof Output:    
       Transformation Details:
       -----------------------
         We have computed the following set of weak (innermost) dependency pairs:
         
           {  1: __^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))
            , 2: __^#(X, nil()) -> c_1(X)
            , 3: __^#(nil(), X) -> c_2(X)
            , 4: U11^#(tt(), V) -> c_3(U12^#(isNeList(V)))
            , 5: U12^#(tt()) -> c_4()
            , 6: U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))
            , 7: U22^#(tt(), V2) -> c_6(U23^#(isList(V2)))
            , 8: U23^#(tt()) -> c_7()
            , 9: U31^#(tt(), V) -> c_8(U32^#(isQid(V)))
            , 10: U32^#(tt()) -> c_9()
            , 11: U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))
            , 12: U42^#(tt(), V2) -> c_11(U43^#(isNeList(V2)))
            , 13: U43^#(tt()) -> c_12()
            , 14: U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))
            , 15: U52^#(tt(), V2) -> c_14(U53^#(isList(V2)))
            , 16: U53^#(tt()) -> c_15()
            , 17: U61^#(tt(), V) -> c_16(U62^#(isQid(V)))
            , 18: U62^#(tt()) -> c_17()
            , 19: U71^#(tt(), V) -> c_18(U72^#(isNePal(V)))
            , 20: U72^#(tt()) -> c_19()
            , 21: and^#(tt(), X) -> c_20(X)
            , 22: isList^#(V) -> c_21(U11^#(isPalListKind(V), V))
            , 23: isList^#(nil()) -> c_22()
            , 24: isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
            , 25: isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))
            , 26: isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
            , 27: isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
            , 28: isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))
            , 29: isNePal^#(__(I, __(P, I))) ->
                  c_28(and^#(and(isQid(I), isPalListKind(I)),
                             and(isPal(P), isPalListKind(P))))
            , 30: isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))
            , 31: isPal^#(nil()) -> c_30()
            , 32: isPalListKind^#(a()) -> c_31()
            , 33: isPalListKind^#(e()) -> c_32()
            , 34: isPalListKind^#(i()) -> c_33()
            , 35: isPalListKind^#(nil()) -> c_34()
            , 36: isPalListKind^#(o()) -> c_35()
            , 37: isPalListKind^#(u()) -> c_36()
            , 38: isPalListKind^#(__(V1, V2)) ->
                  c_37(and^#(isPalListKind(V1), isPalListKind(V2)))
            , 39: isQid^#(a()) -> c_38()
            , 40: isQid^#(e()) -> c_39()
            , 41: isQid^#(i()) -> c_40()
            , 42: isQid^#(o()) -> c_41()
            , 43: isQid^#(u()) -> c_42()}
         
         Following Dependency Graph (modulo SCCs) was computed. (Answers to
         subproofs are indicated to the right.)
         
           ->{43}                                                      [    YES(?,O(1))     ]
           
           ->{42}                                                      [    YES(?,O(1))     ]
           
           ->{41}                                                      [    YES(?,O(1))     ]
           
           ->{40}                                                      [    YES(?,O(1))     ]
           
           ->{39}                                                      [    YES(?,O(1))     ]
           
           ->{38}                                                      [    YES(?,O(1))     ]
              |
              `->{21}                                                  [    YES(?,O(1))     ]
           
           ->{37}                                                      [    YES(?,O(1))     ]
           
           ->{36}                                                      [    YES(?,O(1))     ]
           
           ->{35}                                                      [    YES(?,O(1))     ]
           
           ->{34}                                                      [    YES(?,O(1))     ]
           
           ->{33}                                                      [    YES(?,O(1))     ]
           
           ->{32}                                                      [    YES(?,O(1))     ]
           
           ->{31}                                                      [    YES(?,O(1))     ]
           
           ->{30}                                                      [    YES(?,O(1))     ]
              |
              `->{19}                                                  [    YES(?,O(1))     ]
                  |
                  `->{20}                                              [    YES(?,O(1))     ]
           
           ->{29}                                                      [    YES(?,O(1))     ]
              |
              `->{21}                                                  [    YES(?,O(1))     ]
           
           ->{28}                                                      [    YES(?,O(1))     ]
              |
              `->{17}                                                  [    YES(?,O(1))     ]
                  |
                  `->{18}                                              [    YES(?,O(1))     ]
           
           ->{27}                                                      [    YES(?,O(1))     ]
              |
              `->{14}                                                  [    YES(?,O(1))     ]
                  |
                  `->{15}                                              [    YES(?,O(1))     ]
                      |
                      `->{16}                                          [    YES(?,O(1))     ]
           
           ->{26}                                                      [    YES(?,O(1))     ]
              |
              `->{11}                                                  [    YES(?,O(1))     ]
                  |
                  `->{12}                                              [    YES(?,O(1))     ]
                      |
                      `->{13}                                          [    YES(?,O(1))     ]
           
           ->{25}                                                      [    YES(?,O(1))     ]
              |
              `->{9}                                                   [    YES(?,O(1))     ]
                  |
                  `->{10}                                              [    YES(?,O(1))     ]
           
           ->{24}                                                      [    YES(?,O(1))     ]
              |
              `->{6}                                                   [    YES(?,O(1))     ]
                  |
                  `->{7}                                               [    YES(?,O(1))     ]
                      |
                      `->{8}                                           [    YES(?,O(1))     ]
           
           ->{23}                                                      [    YES(?,O(1))     ]
           
           ->{22}                                                      [    YES(?,O(1))     ]
              |
              `->{4}                                                   [    YES(?,O(1))     ]
                  |
                  `->{5}                                               [    YES(?,O(1))     ]
           
           ->{1}                                                       [    YES(?,O(1))     ]
              |
              |->{2}                                                   [    YES(?,O(1))     ]
              |
              `->{3}                                                   [    YES(?,O(1))     ]
           
         
       
       Sub-problems:
       -------------
         * Path {1}: YES(?,O(1))
           ---------------------
           
           The usable rules for this path are:
           
             {  __(__(X, Y), Z) -> __(X, __(Y, Z))
              , __(X, nil()) -> X
              , __(nil(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {2}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {2},
               Uargs(c_0) = {1}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [1] x2 + [1]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [3] x1 + [1] x2 + [0]
              c_0(x1) = [1] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {__^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))}
             Weak Rules:
               {  __(__(X, Y), Z) -> __(X, __(Y, Z))
                , __(X, nil()) -> X
                , __(nil(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(__^#) = {}, Uargs(c_0) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [1] x2 + [1]
              nil() = [7]
              __^#(x1, x2) = [4] x1 + [0] x2 + [0]
              c_0(x1) = [2] x1 + [3]
         
         * Path {1}->{2}: YES(?,O(1))
           --------------------------
           
           The usable rules for this path are:
           
             {  __(__(X, Y), Z) -> __(X, __(Y, Z))
              , __(X, nil()) -> X
              , __(nil(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {2}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {2},
               Uargs(c_0) = {1}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [1] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_0(x1) = [1] x1 + [0]
              c_1(x1) = [1] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {__^#(X, nil()) -> c_1(X)}
             Weak Rules:
               {  __^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))
                , __(__(X, Y), Z) -> __(X, __(Y, Z))
                , __(X, nil()) -> X
                , __(nil(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(__^#) = {}, Uargs(c_0) = {1}, Uargs(c_1) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [1] x2 + [2]
              nil() = [2]
              __^#(x1, x2) = [6] x1 + [2] x2 + [0]
              c_0(x1) = [1] x1 + [7]
              c_1(x1) = [0] x1 + [1]
         
         * Path {1}->{3}: YES(?,O(1))
           --------------------------
           
           The usable rules for this path are:
           
             {  __(__(X, Y), Z) -> __(X, __(Y, Z))
              , __(X, nil()) -> X
              , __(nil(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {2}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {2},
               Uargs(c_0) = {1}, Uargs(c_1) = {}, Uargs(c_2) = {1},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [1] x2 + [1]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [3] x2 + [0]
              c_0(x1) = [1] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [1] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {__^#(nil(), X) -> c_2(X)}
             Weak Rules:
               {  __^#(__(X, Y), Z) -> c_0(__^#(X, __(Y, Z)))
                , __(__(X, Y), Z) -> __(X, __(Y, Z))
                , __(X, nil()) -> X
                , __(nil(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(__^#) = {}, Uargs(c_0) = {1},
               Uargs(c_2) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [1] x2 + [2]
              nil() = [2]
              __^#(x1, x2) = [2] x1 + [2] x2 + [4]
              c_0(x1) = [1] x1 + [0]
              c_2(x1) = [1] x1 + [1]
         
         * Path {22}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {1}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {1}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [3] x1 + [0]
              c_21(x1) = [1] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isList^#(V) -> c_21(U11^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U11^#) = {}, Uargs(isList^#) = {}, Uargs(c_21) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U11^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isList^#(x1) = [7] x1 + [7]
              c_21(x1) = [2] x1 + [3]
         
         * Path {22}->{4}: YES(?,O(1))
           ---------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {1}, Uargs(c_3) = {1}, Uargs(U12^#) = {1},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {1}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [3]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [2] x1 + [0] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [0] x1 + [3]
              U41(x1, x2, x3) = [2] x1 + [3] x2 + [2] x3 + [2]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_3(x1) = [1] x1 + [0]
              U12^#(x1) = [1] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [1] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U11^#(tt(), V) -> c_3(U12^#(isNeList(V)))}
             Weak Rules:
               {  isList^#(V) -> c_21(U11^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {1}, Uargs(U12^#) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [0] x2 + [0]
              nil() = [1]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [4] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [0]
              U11^#(x1, x2) = [0] x1 + [4] x2 + [4]
              c_3(x1) = [2] x1 + [3]
              U12^#(x1) = [2] x1 + [0]
              isList^#(x1) = [7] x1 + [7]
              c_21(x1) = [1] x1 + [3]
         
         * Path {22}->{4}->{5}: YES(?,O(1))
           --------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {1}, Uargs(c_3) = {1}, Uargs(U12^#) = {1},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {1}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [3]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [1]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [1] x1 + [2] x2 + [3] x3 + [3]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [1]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_3(x1) = [1] x1 + [0]
              U12^#(x1) = [3] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [1] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U12^#(tt()) -> c_4()}
             Weak Rules:
               {  U11^#(tt(), V) -> c_3(U12^#(isNeList(V)))
                , isList^#(V) -> c_21(U11^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {1}, Uargs(U12^#) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [0] x2 + [2]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [1] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [1] x2 + [0] x3 + [4]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [4] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [1] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [3] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [0]
              o() = [0]
              u() = [2]
              U11^#(x1, x2) = [0] x1 + [4] x2 + [4]
              c_3(x1) = [2] x1 + [0]
              U12^#(x1) = [2] x1 + [1]
              c_4() = [0]
              isList^#(x1) = [7] x1 + [7]
              c_21(x1) = [1] x1 + [3]
         
         * Path {23}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isList^#(nil()) -> c_22()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isList^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              nil() = [7]
              isList^#(x1) = [1] x1 + [7]
              c_22() = [1]
         
         * Path {24}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {1}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [3] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules:
               {isList^#(__(V1, V2)) ->
                c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(isList^#) = {}, Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [2]
              u() = [2]
              U21^#(x1, x2, x3) = [1] x1 + [0] x2 + [0] x3 + [0]
              isList^#(x1) = [2] x1 + [1]
              c_23(x1) = [2] x1 + [3]
         
         * Path {24}->{6}: YES(?,O(1))
           ---------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {1}, Uargs(c_5) = {1}, Uargs(U22^#) = {1},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [1] x2 + [1]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              c_5(x1) = [1] x1 + [0]
              U22^#(x1, x2) = [1] x1 + [3] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))}
             Weak Rules:
               {  isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {1}, Uargs(U22^#) = {},
               Uargs(isList^#) = {}, Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [2]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [6] x1 + [0]
              U21(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [2] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [2] x1 + [5] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U21^#(x1, x2, x3) = [3] x1 + [2] x2 + [0] x3 + [2]
              c_5(x1) = [4] x1 + [1]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              isList^#(x1) = [3] x1 + [4]
              c_23(x1) = [2] x1 + [3]
         
         * Path {24}->{6}->{7}: YES(?,O(1))
           --------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {1}, Uargs(c_5) = {1}, Uargs(U22^#) = {1},
               Uargs(c_6) = {1}, Uargs(U23^#) = {1}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [3] x3 + [3]
              U42(x1, x2) = [1] x1 + [3] x2 + [2]
              U43(x1) = [1] x1 + [2]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [1]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [1] x1 + [0]
              U22^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_6(x1) = [1] x1 + [0]
              U23^#(x1) = [1] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U22^#(tt(), V2) -> c_6(U23^#(isList(V2)))}
             Weak Rules:
               {  U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))
                , isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {1}, Uargs(U22^#) = {},
               Uargs(c_6) = {1}, Uargs(U23^#) = {}, Uargs(isList^#) = {},
               Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [4] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [4] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [4] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [5] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [4] x3 + [4]
              c_5(x1) = [1] x1 + [1]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [2]
              c_6(x1) = [2] x1 + [1]
              U23^#(x1) = [2] x1 + [0]
              isList^#(x1) = [4] x1 + [7]
              c_23(x1) = [1] x1 + [3]
         
         * Path {24}->{6}->{7}->{8}: YES(?,O(1))
           -------------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {1}, Uargs(c_5) = {1}, Uargs(U22^#) = {1},
               Uargs(c_6) = {1}, Uargs(U23^#) = {1}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {1}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [2] x1 + [0] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [0] x1 + [3]
              U41(x1, x2, x3) = [3] x1 + [3] x2 + [2] x3 + [0]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [1] x1 + [0]
              U22^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_6(x1) = [1] x1 + [0]
              U23^#(x1) = [3] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [1] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U23^#(tt()) -> c_7()}
             Weak Rules:
               {  U22^#(tt(), V2) -> c_6(U23^#(isList(V2)))
                , U21^#(tt(), V1, V2) -> c_5(U22^#(isList(V1), V2))
                , isList^#(__(V1, V2)) ->
                  c_23(U21^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {1}, Uargs(U22^#) = {},
               Uargs(c_6) = {1}, Uargs(U23^#) = {}, Uargs(isList^#) = {},
               Uargs(c_23) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [6] x2 + [4]
              nil() = [3]
              U11(x1, x2) = [2] x1 + [0] x2 + [0]
              tt() = [3]
              U12(x1) = [0] x1 + [3]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [4] x1 + [1] x2 + [6] x3 + [0]
              U22(x1, x2) = [0] x1 + [6] x2 + [0]
              isList(x1) = [2] x1 + [0]
              U23(x1) = [3] x1 + [0]
              U31(x1, x2) = [2] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [3]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [4] x2 + [4] x3 + [4]
              U42(x1, x2) = [2] x1 + [4] x2 + [0]
              U43(x1) = [2] x1 + [0]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [6] x3 + [0]
              U52(x1, x2) = [2] x1 + [6] x2 + [0]
              U53(x1) = [2] x1 + [0]
              and(x1, x2) = [0] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              a() = [4]
              e() = [6]
              i() = [4]
              o() = [6]
              u() = [4]
              U21^#(x1, x2, x3) = [2] x1 + [0] x2 + [4] x3 + [2]
              c_5(x1) = [1] x1 + [5]
              U22^#(x1, x2) = [0] x1 + [4] x2 + [2]
              c_6(x1) = [1] x1 + [0]
              U23^#(x1) = [2] x1 + [2]
              c_7() = [1]
              isList^#(x1) = [2] x1 + [7]
              c_23(x1) = [2] x1 + [3]
         
         * Path {25}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {1},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {1}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [3] x1 + [0]
              c_24(x1) = [1] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U31^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_24) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U31^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isNeList^#(x1) = [7] x1 + [7]
              c_24(x1) = [2] x1 + [3]
         
         * Path {25}->{9}: YES(?,O(1))
           ---------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {1},
               Uargs(c_8) = {1}, Uargs(U32^#) = {1}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {1}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_8(x1) = [1] x1 + [0]
              U32^#(x1) = [1] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [1] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U31^#(tt(), V) -> c_8(U32^#(isQid(V)))}
             Weak Rules:
               {  isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {1},
               Uargs(U32^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_24) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_8(x1) = [2] x1 + [0]
              U32^#(x1) = [2] x1 + [0]
              isNeList^#(x1) = [7] x1 + [7]
              c_24(x1) = [4] x1 + [3]
         
         * Path {25}->{9}->{10}: YES(?,O(1))
           ---------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {1},
               Uargs(c_8) = {1}, Uargs(U32^#) = {1}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {1}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_8(x1) = [1] x1 + [0]
              U32^#(x1) = [3] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [1] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U32^#(tt()) -> c_9()}
             Weak Rules:
               {  U31^#(tt(), V) -> c_8(U32^#(isQid(V)))
                , isNeList^#(V) -> c_24(U31^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U31^#) = {}, Uargs(c_8) = {1},
               Uargs(U32^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_24) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [2] x2 + [6]
              nil() = [0]
              tt() = [3]
              isQid(x1) = [1] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [3]
              a() = [3]
              e() = [6]
              i() = [3]
              o() = [3]
              u() = [3]
              U31^#(x1, x2) = [2] x1 + [4] x2 + [0]
              c_8(x1) = [2] x1 + [2]
              U32^#(x1) = [2] x1 + [2]
              c_9() = [1]
              isNeList^#(x1) = [7] x1 + [7]
              c_24(x1) = [1] x1 + [1]
         
         * Path {26}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {1},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [3] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules:
               {isNeList^#(__(V1, V2)) ->
                c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [2]
              u() = [2]
              U41^#(x1, x2, x3) = [1] x1 + [0] x2 + [0] x3 + [0]
              isNeList^#(x1) = [2] x1 + [1]
              c_25(x1) = [2] x1 + [3]
         
         * Path {26}->{11}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {1},
               Uargs(c_10) = {1}, Uargs(U42^#) = {1}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [1] x2 + [1]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [1] x1 + [3] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))}
             Weak Rules:
               {  isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {1}, Uargs(U42^#) = {},
               Uargs(isNeList^#) = {}, Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [2]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [6] x1 + [0]
              U21(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [2] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [2] x1 + [5] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U41^#(x1, x2, x3) = [3] x1 + [2] x2 + [0] x3 + [2]
              c_10(x1) = [4] x1 + [1]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              isNeList^#(x1) = [3] x1 + [4]
              c_25(x1) = [2] x1 + [3]
         
         * Path {26}->{11}->{12}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {1},
               Uargs(c_10) = {1}, Uargs(U42^#) = {1}, Uargs(c_11) = {1},
               Uargs(U43^#) = {1}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [3] x3 + [3]
              U42(x1, x2) = [1] x1 + [3] x2 + [2]
              U43(x1) = [1] x1 + [2]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [1]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_11(x1) = [1] x1 + [0]
              U43^#(x1) = [1] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U42^#(tt(), V2) -> c_11(U43^#(isNeList(V2)))}
             Weak Rules:
               {  U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {1}, Uargs(U42^#) = {},
               Uargs(c_11) = {1}, Uargs(U43^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [6] x2 + [4]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [6] x3 + [4]
              c_10(x1) = [2] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [2]
              c_11(x1) = [2] x1 + [1]
              U43^#(x1) = [2] x1 + [0]
              isNeList^#(x1) = [2] x1 + [7]
              c_25(x1) = [2] x1 + [7]
         
         * Path {26}->{11}->{12}->{13}: YES(?,O(1))
           ----------------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U23(tt()) -> tt()
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {1},
               Uargs(c_10) = {1}, Uargs(U42^#) = {1}, Uargs(c_11) = {1},
               Uargs(U43^#) = {1}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {1}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [2] x1 + [0] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [0] x1 + [3]
              U41(x1, x2, x3) = [3] x1 + [3] x2 + [2] x3 + [0]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_11(x1) = [1] x1 + [0]
              U43^#(x1) = [3] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [1] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U43^#(tt()) -> c_12()}
             Weak Rules:
               {  U42^#(tt(), V2) -> c_11(U43^#(isNeList(V2)))
                , U41^#(tt(), V1, V2) -> c_10(U42^#(isList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_25(U41^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U23(tt()) -> tt()
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {1}, Uargs(U42^#) = {},
               Uargs(c_11) = {1}, Uargs(U43^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_25) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [6] x2 + [6]
              nil() = [6]
              U11(x1, x2) = [0] x1 + [0] x2 + [4]
              tt() = [3]
              U12(x1) = [0] x1 + [3]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [3]
              U22(x1, x2) = [0] x1 + [0] x2 + [3]
              isList(x1) = [1] x1 + [4]
              U23(x1) = [0] x1 + [3]
              U31(x1, x2) = [0] x1 + [2] x2 + [2]
              U32(x1) = [1] x1 + [0]
              isQid(x1) = [2] x1 + [1]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [2] x3 + [4]
              U42(x1, x2) = [0] x1 + [2] x2 + [3]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [4] x2 + [2] x3 + [2]
              U52(x1, x2) = [0] x1 + [2] x2 + [4]
              U53(x1) = [0] x1 + [4]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [3]
              a() = [1]
              e() = [2]
              i() = [2]
              o() = [1]
              u() = [4]
              U41^#(x1, x2, x3) = [2] x1 + [0] x2 + [4] x3 + [0]
              c_10(x1) = [1] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [4] x2 + [6]
              c_11(x1) = [1] x1 + [0]
              U43^#(x1) = [2] x1 + [2]
              c_12() = [1]
              isNeList^#(x1) = [2] x1 + [3]
              c_25(x1) = [2] x1 + [3]
         
         * Path {27}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {1}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [3] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules:
               {isNeList^#(__(V1, V2)) ->
                c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(isNeList^#) = {}, Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [2]
              u() = [2]
              U51^#(x1, x2, x3) = [1] x1 + [0] x2 + [0] x3 + [0]
              isNeList^#(x1) = [2] x1 + [1]
              c_26(x1) = [2] x1 + [3]
         
         * Path {27}->{14}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {1}, Uargs(c_13) = {1},
               Uargs(U52^#) = {1}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [2]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [2]
              U21(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [3]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [1]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [1]
              U41(x1, x2, x3) = [3] x1 + [3] x2 + [2] x3 + [1]
              U42(x1, x2) = [1] x1 + [2] x2 + [3]
              U43(x1) = [1] x1 + [2]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [2]
              U52(x1, x2) = [1] x1 + [3] x2 + [3]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [3] x1 + [3] x2 + [3] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [1] x1 + [3] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules:
               {U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))}
             Weak Rules:
               {  isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {1}, Uargs(U52^#) = {},
               Uargs(isNeList^#) = {}, Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [4]
              U11(x1, x2) = [0] x1 + [0] x2 + [3]
              tt() = [3]
              U12(x1) = [0] x1 + [3]
              isNeList(x1) = [6] x1 + [1]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [3]
              U22(x1, x2) = [0] x1 + [0] x2 + [3]
              isList(x1) = [0] x1 + [3]
              U23(x1) = [0] x1 + [3]
              U31(x1, x2) = [1] x1 + [4] x2 + [1]
              U32(x1) = [3] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [3] x1 + [0] x2 + [2] x3 + [4]
              U42(x1, x2) = [2] x1 + [0] x2 + [2]
              U43(x1) = [0] x1 + [4]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [4]
              U52(x1, x2) = [0] x1 + [0] x2 + [3]
              U53(x1) = [0] x1 + [3]
              and(x1, x2) = [0] x1 + [1] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              a() = [4]
              e() = [4]
              i() = [3]
              o() = [3]
              u() = [3]
              U51^#(x1, x2, x3) = [2] x1 + [0] x2 + [0] x3 + [2]
              c_13(x1) = [1] x1 + [7]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              isNeList^#(x1) = [3] x1 + [7]
              c_26(x1) = [2] x1 + [1]
         
         * Path {27}->{14}->{15}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {1}, Uargs(c_13) = {1},
               Uargs(U52^#) = {1}, Uargs(c_14) = {1}, Uargs(U53^#) = {1},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [2]
              U22(x1, x2) = [1] x1 + [3] x2 + [3]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [2]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [2] x3 + [3]
              U42(x1, x2) = [1] x1 + [2] x2 + [2]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_14(x1) = [1] x1 + [0]
              U53^#(x1) = [1] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U52^#(tt(), V2) -> c_14(U53^#(isList(V2)))}
             Weak Rules:
               {  U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {1}, Uargs(U52^#) = {},
               Uargs(c_14) = {1}, Uargs(U53^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [4] x1 + [4] x2 + [4]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [1] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [4]
              U41(x1, x2, x3) = [0] x1 + [4] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [1] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [0] x1 + [4]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [2] x3 + [5]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [5]
              c_14(x1) = [2] x1 + [0]
              U53^#(x1) = [2] x1 + [2]
              isNeList^#(x1) = [2] x1 + [7]
              c_26(x1) = [2] x1 + [1]
         
         * Path {27}->{14}->{15}->{16}: YES(?,O(1))
           ----------------------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isNeList(V) -> U31(isPalListKind(V), V)
              , isNeList(__(V1, V2)) ->
                U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isNeList(__(V1, V2)) ->
                U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , U31(tt(), V) -> U32(isQid(V))
              , U41(tt(), V1, V2) -> U42(isList(V1), V2)
              , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
              , U32(tt()) -> tt()
              , U42(tt(), V2) -> U43(isNeList(V2))
              , U52(tt(), V2) -> U53(isList(V2))
              , isList(V) -> U11(isPalListKind(V), V)
              , isList(nil()) -> tt()
              , isList(__(V1, V2)) ->
                U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U11(tt(), V) -> U12(isNeList(V))
              , U21(tt(), V1, V2) -> U22(isList(V1), V2)
              , U43(tt()) -> tt()
              , U53(tt()) -> tt()
              , U12(tt()) -> tt()
              , U22(tt(), V2) -> U23(isList(V2))
              , U23(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {1}, Uargs(U12) = {1},
               Uargs(isNeList) = {}, Uargs(U21) = {1}, Uargs(U22) = {1},
               Uargs(isList) = {}, Uargs(U23) = {1}, Uargs(U31) = {1},
               Uargs(U32) = {1}, Uargs(isQid) = {}, Uargs(U41) = {1},
               Uargs(U42) = {1}, Uargs(U43) = {1}, Uargs(U51) = {1},
               Uargs(U52) = {1}, Uargs(U53) = {1}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {1}, Uargs(c_13) = {1},
               Uargs(U52^#) = {1}, Uargs(c_14) = {1}, Uargs(U53^#) = {1},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [1] x1 + [2] x2 + [1]
              tt() = [2]
              U12(x1) = [1] x1 + [1]
              isNeList(x1) = [2] x1 + [1]
              U21(x1, x2, x3) = [2] x1 + [3] x2 + [3] x3 + [1]
              U22(x1, x2) = [1] x1 + [3] x2 + [2]
              isList(x1) = [3] x1 + [2]
              U23(x1) = [1] x1 + [1]
              U31(x1, x2) = [1] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [1]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [1] x1 + [3] x2 + [3] x3 + [2]
              U42(x1, x2) = [1] x1 + [3] x2 + [1]
              U43(x1) = [1] x1 + [1]
              U51(x1, x2, x3) = [2] x1 + [2] x2 + [3] x3 + [0]
              U52(x1, x2) = [1] x1 + [3] x2 + [2]
              U53(x1) = [1] x1 + [1]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [3] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_14(x1) = [1] x1 + [0]
              U53^#(x1) = [3] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [1] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U53^#(tt()) -> c_15()}
             Weak Rules:
               {  U52^#(tt(), V2) -> c_14(U53^#(isList(V2)))
                , U51^#(tt(), V1, V2) -> c_13(U52^#(isNeList(V1), V2))
                , isNeList^#(__(V1, V2)) ->
                  c_26(U51^#(and(isPalListKind(V1), isPalListKind(V2)), V1, V2))
                , and(tt(), X) -> X
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isNeList(V) -> U31(isPalListKind(V), V)
                , isNeList(__(V1, V2)) ->
                  U41(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isNeList(__(V1, V2)) ->
                  U51(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , U31(tt(), V) -> U32(isQid(V))
                , U41(tt(), V1, V2) -> U42(isList(V1), V2)
                , U51(tt(), V1, V2) -> U52(isNeList(V1), V2)
                , U32(tt()) -> tt()
                , U42(tt(), V2) -> U43(isNeList(V2))
                , U52(tt(), V2) -> U53(isList(V2))
                , isList(V) -> U11(isPalListKind(V), V)
                , isList(nil()) -> tt()
                , isList(__(V1, V2)) ->
                  U21(and(isPalListKind(V1), isPalListKind(V2)), V1, V2)
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U11(tt(), V) -> U12(isNeList(V))
                , U21(tt(), V1, V2) -> U22(isList(V1), V2)
                , U43(tt()) -> tt()
                , U53(tt()) -> tt()
                , U12(tt()) -> tt()
                , U22(tt(), V2) -> U23(isList(V2))
                , U23(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U51^#) = {}, Uargs(c_13) = {1}, Uargs(U52^#) = {},
               Uargs(c_14) = {1}, Uargs(U53^#) = {}, Uargs(isNeList^#) = {},
               Uargs(c_26) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [1] x2 + [0]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [1] x2 + [0]
              tt() = [2]
              U12(x1) = [1] x1 + [0]
              isNeList(x1) = [1] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [1] x2 + [1] x3 + [1]
              U22(x1, x2) = [0] x1 + [1] x2 + [1]
              isList(x1) = [1] x1 + [1]
              U23(x1) = [1] x1 + [0]
              U31(x1, x2) = [0] x1 + [1] x2 + [0]
              U32(x1) = [1] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [2] x2 + [1] x3 + [0]
              U42(x1, x2) = [0] x1 + [1] x2 + [0]
              U43(x1) = [1] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [2] x2 + [0] x3 + [0]
              U52(x1, x2) = [2] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [4]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [0] x1 + [2]
              a() = [4]
              e() = [4]
              i() = [2]
              o() = [4]
              u() = [2]
              U51^#(x1, x2, x3) = [0] x1 + [6] x2 + [4] x3 + [0]
              c_13(x1) = [1] x1 + [0]
              U52^#(x1, x2) = [6] x1 + [4] x2 + [0]
              c_14(x1) = [2] x1 + [0]
              U53^#(x1) = [2] x1 + [4]
              c_15() = [1]
              isNeList^#(x1) = [4] x1 + [7]
              c_26(x1) = [1] x1 + [3]
         
         * Path {28}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {1}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {1}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [3] x1 + [0]
              c_27(x1) = [1] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U61^#) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U61^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isNePal^#(x1) = [7] x1 + [7]
              c_27(x1) = [2] x1 + [3]
         
         * Path {28}->{17}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {1}, Uargs(c_16) = {1}, Uargs(U62^#) = {1},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {1}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_16(x1) = [1] x1 + [0]
              U62^#(x1) = [1] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [1] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U61^#(tt(), V) -> c_16(U62^#(isQid(V)))}
             Weak Rules:
               {  isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {1},
               Uargs(U62^#) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_16(x1) = [2] x1 + [0]
              U62^#(x1) = [2] x1 + [0]
              isNePal^#(x1) = [7] x1 + [7]
              c_27(x1) = [4] x1 + [3]
         
         * Path {28}->{17}->{18}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {1}, Uargs(c_16) = {1}, Uargs(U62^#) = {1},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {1}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [2] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [2]
              e() = [2]
              i() = [2]
              o() = [2]
              u() = [2]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_16(x1) = [1] x1 + [0]
              U62^#(x1) = [3] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [1] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U62^#(tt()) -> c_17()}
             Weak Rules:
               {  U61^#(tt(), V) -> c_16(U62^#(isQid(V)))
                , isNePal^#(V) -> c_27(U61^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {1},
               Uargs(U62^#) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [2] x2 + [6]
              nil() = [0]
              tt() = [3]
              isQid(x1) = [1] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [3]
              a() = [3]
              e() = [6]
              i() = [3]
              o() = [3]
              u() = [3]
              U61^#(x1, x2) = [2] x1 + [4] x2 + [0]
              c_16(x1) = [2] x1 + [2]
              U62^#(x1) = [2] x1 + [2]
              c_17() = [1]
              isNePal^#(x1) = [7] x1 + [7]
              c_27(x1) = [1] x1 + [1]
         
         * Path {29}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , U62(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(c_1) = {},
               Uargs(c_2) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {1, 2}, Uargs(c_20) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {1}, Uargs(isPal^#) = {}, Uargs(c_29) = {},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [1]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [3] x1 + [2]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [2] x1 + [2] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [2] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [1] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules:
               {isNePal^#(__(I, __(P, I))) ->
                c_28(and^#(and(isQid(I), isPalListKind(I)),
                           and(isPal(P), isPalListKind(P))))}
             Weak Rules:
               {  and(tt(), X) -> X
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , U62(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(and^#) = {}, Uargs(isNePal^#) = {},
               Uargs(c_28) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [6] x1 + [1] x2 + [2]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [1] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [2] x1 + [0]
              and(x1, x2) = [1] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [2] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              and^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isNePal^#(x1) = [2] x1 + [5]
              c_28(x1) = [2] x1 + [3]
         
         * Path {29}->{21}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  and(tt(), X) -> X
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , U62(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(c_1) = {},
               Uargs(c_2) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {},
               Uargs(U72^#) = {}, Uargs(and^#) = {1, 2}, Uargs(c_20) = {1},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {1}, Uargs(isPal^#) = {}, Uargs(c_29) = {},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [3] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [1]
              and(x1, x2) = [1] x1 + [2] x2 + [2]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [3] x1 + [2]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_20(x1) = [1] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [1] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {and^#(tt(), X) -> c_20(X)}
             Weak Rules:
               {  isNePal^#(__(I, __(P, I))) ->
                  c_28(and^#(and(isQid(I), isPalListKind(I)),
                             and(isPal(P), isPalListKind(P))))
                , and(tt(), X) -> X
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , U62(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(and^#) = {}, Uargs(c_20) = {1},
               Uargs(isNePal^#) = {}, Uargs(c_28) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [1]
              nil() = [0]
              tt() = [2]
              isQid(x1) = [0] x1 + [4]
              U61(x1, x2) = [0] x1 + [0] x2 + [2]
              U62(x1) = [0] x1 + [2]
              U71(x1, x2) = [0] x1 + [0] x2 + [2]
              U72(x1) = [0] x1 + [2]
              isNePal(x1) = [0] x1 + [4]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [0] x1 + [2]
              isPal(x1) = [0] x1 + [4]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              and^#(x1, x2) = [2] x1 + [1] x2 + [0]
              c_20(x1) = [1] x1 + [1]
              isNePal^#(x1) = [2] x1 + [7]
              c_28(x1) = [2] x1 + [1]
         
         * Path {30}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {1}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {1},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [3] x1 + [0]
              c_29(x1) = [1] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(U71^#) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              and(x1, x2) = [0] x1 + [4] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U71^#(x1, x2) = [2] x1 + [3] x2 + [0]
              isPal^#(x1) = [7] x1 + [7]
              c_29(x1) = [2] x1 + [3]
         
         * Path {30}->{19}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U62(tt()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(c_1) = {},
               Uargs(c_2) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {1}, Uargs(c_18) = {1},
               Uargs(U72^#) = {1}, Uargs(and^#) = {}, Uargs(c_20) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [2] x2 + [1]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [2]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [1]
              and(x1, x2) = [1] x1 + [2] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [3] x1 + [2]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_18(x1) = [1] x1 + [0]
              U72^#(x1) = [1] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [1] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U71^#(tt(), V) -> c_18(U72^#(isNePal(V)))}
             Weak Rules:
               {  isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U62(tt()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {1},
               Uargs(U72^#) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              tt() = [0]
              isQid(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [2] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [1]
              c_18(x1) = [2] x1 + [0]
              U72^#(x1) = [2] x1 + [0]
              isPal^#(x1) = [7] x1 + [7]
              c_29(x1) = [4] x1 + [3]
         
         * Path {30}->{19}->{20}: YES(?,O(1))
           ----------------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X
              , isNePal(V) -> U61(isPalListKind(V), V)
              , isNePal(__(I, __(P, I))) ->
                and(and(isQid(I), isPalListKind(I)),
                    and(isPal(P), isPalListKind(P)))
              , U61(tt(), V) -> U62(isQid(V))
              , isPal(V) -> U71(isPalListKind(V), V)
              , isPal(nil()) -> tt()
              , isQid(a()) -> tt()
              , isQid(e()) -> tt()
              , isQid(i()) -> tt()
              , isQid(o()) -> tt()
              , isQid(u()) -> tt()
              , U62(tt()) -> tt()
              , U71(tt(), V) -> U72(isNePal(V))
              , U72(tt()) -> tt()}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {1}, Uargs(U62) = {1},
               Uargs(U71) = {1}, Uargs(U72) = {1}, Uargs(isNePal) = {},
               Uargs(and) = {1, 2}, Uargs(isPalListKind) = {}, Uargs(isPal) = {},
               Uargs(__^#) = {}, Uargs(c_0) = {}, Uargs(c_1) = {},
               Uargs(c_2) = {}, Uargs(U11^#) = {}, Uargs(c_3) = {},
               Uargs(U12^#) = {}, Uargs(U21^#) = {}, Uargs(c_5) = {},
               Uargs(U22^#) = {}, Uargs(c_6) = {}, Uargs(U23^#) = {},
               Uargs(U31^#) = {}, Uargs(c_8) = {}, Uargs(U32^#) = {},
               Uargs(U41^#) = {}, Uargs(c_10) = {}, Uargs(U42^#) = {},
               Uargs(c_11) = {}, Uargs(U43^#) = {}, Uargs(U51^#) = {},
               Uargs(c_13) = {}, Uargs(U52^#) = {}, Uargs(c_14) = {},
               Uargs(U53^#) = {}, Uargs(U61^#) = {}, Uargs(c_16) = {},
               Uargs(U62^#) = {}, Uargs(U71^#) = {1}, Uargs(c_18) = {1},
               Uargs(U72^#) = {1}, Uargs(and^#) = {}, Uargs(c_20) = {},
               Uargs(isList^#) = {}, Uargs(c_21) = {}, Uargs(c_23) = {},
               Uargs(isNeList^#) = {}, Uargs(c_24) = {}, Uargs(c_25) = {},
               Uargs(c_26) = {}, Uargs(isNePal^#) = {}, Uargs(c_27) = {},
               Uargs(c_28) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1},
               Uargs(isPalListKind^#) = {}, Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [3]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [3]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [1] x1 + [1]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [1] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [1]
              U71(x1, x2) = [1] x1 + [2] x2 + [1]
              U72(x1) = [1] x1 + [1]
              isNePal(x1) = [2] x1 + [2]
              and(x1, x2) = [1] x1 + [1] x2 + [1]
              isPalListKind(x1) = [1] x1 + [1]
              isPal(x1) = [3] x1 + [3]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [3] x1 + [0] x2 + [0]
              c_18(x1) = [1] x1 + [0]
              U72^#(x1) = [3] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [1] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {U72^#(tt()) -> c_19()}
             Weak Rules:
               {  U71^#(tt(), V) -> c_18(U72^#(isNePal(V)))
                , isPal^#(V) -> c_29(U71^#(isPalListKind(V), V))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X
                , isNePal(V) -> U61(isPalListKind(V), V)
                , isNePal(__(I, __(P, I))) ->
                  and(and(isQid(I), isPalListKind(I)),
                      and(isPal(P), isPalListKind(P)))
                , U61(tt(), V) -> U62(isQid(V))
                , isPal(V) -> U71(isPalListKind(V), V)
                , isPal(nil()) -> tt()
                , isQid(a()) -> tt()
                , isQid(e()) -> tt()
                , isQid(i()) -> tt()
                , isQid(o()) -> tt()
                , isQid(u()) -> tt()
                , U62(tt()) -> tt()
                , U71(tt(), V) -> U72(isNePal(V))
                , U72(tt()) -> tt()}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(isQid) = {}, Uargs(U61) = {},
               Uargs(U62) = {}, Uargs(U71) = {}, Uargs(U72) = {},
               Uargs(isNePal) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(isPal) = {}, Uargs(U71^#) = {}, Uargs(c_18) = {1},
               Uargs(U72^#) = {}, Uargs(isPal^#) = {}, Uargs(c_29) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [1] x1 + [1] x2 + [4]
              nil() = [4]
              tt() = [2]
              isQid(x1) = [1] x1 + [0]
              U61(x1, x2) = [0] x1 + [1] x2 + [0]
              U62(x1) = [1] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [4]
              U72(x1) = [0] x1 + [4]
              isNePal(x1) = [1] x1 + [0]
              and(x1, x2) = [0] x1 + [1] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              isPal(x1) = [0] x1 + [4]
              a() = [2]
              e() = [4]
              i() = [2]
              o() = [2]
              u() = [2]
              U71^#(x1, x2) = [0] x1 + [4] x2 + [4]
              c_18(x1) = [2] x1 + [3]
              U72^#(x1) = [2] x1 + [0]
              c_19() = [1]
              isPal^#(x1) = [7] x1 + [7]
              c_29(x1) = [1] x1 + [3]
         
         * Path {31}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPal^#(nil()) -> c_30()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPal^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              nil() = [7]
              isPal^#(x1) = [1] x1 + [7]
              c_30() = [1]
         
         * Path {32}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(a()) -> c_31()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              a() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_31() = [1]
         
         * Path {33}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(e()) -> c_32()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              e() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_32() = [1]
         
         * Path {34}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(i()) -> c_33()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              i() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_33() = [1]
         
         * Path {35}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(nil()) -> c_34()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              nil() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_34() = [1]
         
         * Path {36}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(o()) -> c_35()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              o() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_35() = [1]
         
         * Path {37}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isPalListKind^#(u()) -> c_36()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isPalListKind^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              u() = [7]
              isPalListKind^#(x1) = [1] x1 + [7]
              c_36() = [1]
         
         * Path {38}: YES(?,O(1))
           ----------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {1, 2}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {1}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [2] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [1]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [1] x1 + [1] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [1] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [1] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules:
               {isPalListKind^#(__(V1, V2)) ->
                c_37(and^#(isPalListKind(V1), isPalListKind(V2)))}
             Weak Rules:
               {  isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(and^#) = {}, Uargs(isPalListKind^#) = {}, Uargs(c_37) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [6] x1 + [2] x2 + [6]
              nil() = [2]
              tt() = [2]
              and(x1, x2) = [2] x1 + [2] x2 + [0]
              isPalListKind(x1) = [2] x1 + [2]
              a() = [0]
              e() = [0]
              i() = [2]
              o() = [0]
              u() = [2]
              and^#(x1, x2) = [2] x1 + [0] x2 + [0]
              isPalListKind^#(x1) = [2] x1 + [3]
              c_37(x1) = [3] x1 + [1]
         
         * Path {38}->{21}: YES(?,O(1))
           ----------------------------
           
           The usable rules for this path are:
           
             {  isPalListKind(a()) -> tt()
              , isPalListKind(e()) -> tt()
              , isPalListKind(i()) -> tt()
              , isPalListKind(nil()) -> tt()
              , isPalListKind(o()) -> tt()
              , isPalListKind(u()) -> tt()
              , isPalListKind(__(V1, V2)) ->
                and(isPalListKind(V1), isPalListKind(V2))
              , and(tt(), X) -> X}
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {1, 2},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {1, 2}, Uargs(c_20) = {1}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {1}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [3] x1 + [3] x2 + [2]
              nil() = [3]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [1]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [1] x1 + [1] x2 + [0]
              isPalListKind(x1) = [2] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [3]
              e() = [3]
              i() = [3]
              o() = [3]
              u() = [3]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [3] x1 + [3] x2 + [0]
              c_20(x1) = [1] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [1] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           Complexity induced by the adequate RMI: YES(?,O(1))
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {and^#(tt(), X) -> c_20(X)}
             Weak Rules:
               {  isPalListKind^#(__(V1, V2)) ->
                  c_37(and^#(isPalListKind(V1), isPalListKind(V2)))
                , isPalListKind(a()) -> tt()
                , isPalListKind(e()) -> tt()
                , isPalListKind(i()) -> tt()
                , isPalListKind(nil()) -> tt()
                , isPalListKind(o()) -> tt()
                , isPalListKind(u()) -> tt()
                , isPalListKind(__(V1, V2)) ->
                  and(isPalListKind(V1), isPalListKind(V2))
                , and(tt(), X) -> X}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(and) = {}, Uargs(isPalListKind) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {1}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {1}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [2] x1 + [4] x2 + [4]
              nil() = [4]
              tt() = [2]
              and(x1, x2) = [2] x1 + [4] x2 + [0]
              isPalListKind(x1) = [1] x1 + [0]
              a() = [2]
              e() = [4]
              i() = [2]
              o() = [4]
              u() = [2]
              and^#(x1, x2) = [2] x1 + [4] x2 + [4]
              c_20(x1) = [2] x1 + [1]
              isPalListKind^#(x1) = [2] x1 + [7]
              c_37(x1) = [2] x1 + [3]
         
         * Path {39}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isQid^#(a()) -> c_38()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              a() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_38() = [1]
         
         * Path {40}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isQid^#(e()) -> c_39()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              e() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_39() = [1]
         
         * Path {41}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isQid^#(i()) -> c_40()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              i() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_40() = [1]
         
         * Path {42}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isQid^#(o()) -> c_41()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              o() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_41() = [1]
         
         * Path {43}: YES(?,O(1))
           ----------------------
           
           The usable rules of this path are empty.
           
           The weightgap principle applies, using the following adequate RMI:
             The following argument positions are usable:
               Uargs(__) = {}, Uargs(U11) = {}, Uargs(U12) = {},
               Uargs(isNeList) = {}, Uargs(U21) = {}, Uargs(U22) = {},
               Uargs(isList) = {}, Uargs(U23) = {}, Uargs(U31) = {},
               Uargs(U32) = {}, Uargs(isQid) = {}, Uargs(U41) = {},
               Uargs(U42) = {}, Uargs(U43) = {}, Uargs(U51) = {}, Uargs(U52) = {},
               Uargs(U53) = {}, Uargs(U61) = {}, Uargs(U62) = {}, Uargs(U71) = {},
               Uargs(U72) = {}, Uargs(isNePal) = {}, Uargs(and) = {},
               Uargs(isPalListKind) = {}, Uargs(isPal) = {}, Uargs(__^#) = {},
               Uargs(c_0) = {}, Uargs(c_1) = {}, Uargs(c_2) = {},
               Uargs(U11^#) = {}, Uargs(c_3) = {}, Uargs(U12^#) = {},
               Uargs(U21^#) = {}, Uargs(c_5) = {}, Uargs(U22^#) = {},
               Uargs(c_6) = {}, Uargs(U23^#) = {}, Uargs(U31^#) = {},
               Uargs(c_8) = {}, Uargs(U32^#) = {}, Uargs(U41^#) = {},
               Uargs(c_10) = {}, Uargs(U42^#) = {}, Uargs(c_11) = {},
               Uargs(U43^#) = {}, Uargs(U51^#) = {}, Uargs(c_13) = {},
               Uargs(U52^#) = {}, Uargs(c_14) = {}, Uargs(U53^#) = {},
               Uargs(U61^#) = {}, Uargs(c_16) = {}, Uargs(U62^#) = {},
               Uargs(U71^#) = {}, Uargs(c_18) = {}, Uargs(U72^#) = {},
               Uargs(and^#) = {}, Uargs(c_20) = {}, Uargs(isList^#) = {},
               Uargs(c_21) = {}, Uargs(c_23) = {}, Uargs(isNeList^#) = {},
               Uargs(c_24) = {}, Uargs(c_25) = {}, Uargs(c_26) = {},
               Uargs(isNePal^#) = {}, Uargs(c_27) = {}, Uargs(c_28) = {},
               Uargs(isPal^#) = {}, Uargs(c_29) = {}, Uargs(isPalListKind^#) = {},
               Uargs(c_37) = {}, Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              __(x1, x2) = [0] x1 + [0] x2 + [0]
              nil() = [0]
              U11(x1, x2) = [0] x1 + [0] x2 + [0]
              tt() = [0]
              U12(x1) = [0] x1 + [0]
              isNeList(x1) = [0] x1 + [0]
              U21(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U22(x1, x2) = [0] x1 + [0] x2 + [0]
              isList(x1) = [0] x1 + [0]
              U23(x1) = [0] x1 + [0]
              U31(x1, x2) = [0] x1 + [0] x2 + [0]
              U32(x1) = [0] x1 + [0]
              isQid(x1) = [0] x1 + [0]
              U41(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U42(x1, x2) = [0] x1 + [0] x2 + [0]
              U43(x1) = [0] x1 + [0]
              U51(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              U52(x1, x2) = [0] x1 + [0] x2 + [0]
              U53(x1) = [0] x1 + [0]
              U61(x1, x2) = [0] x1 + [0] x2 + [0]
              U62(x1) = [0] x1 + [0]
              U71(x1, x2) = [0] x1 + [0] x2 + [0]
              U72(x1) = [0] x1 + [0]
              isNePal(x1) = [0] x1 + [0]
              and(x1, x2) = [0] x1 + [0] x2 + [0]
              isPalListKind(x1) = [0] x1 + [0]
              isPal(x1) = [0] x1 + [0]
              a() = [0]
              e() = [0]
              i() = [0]
              o() = [0]
              u() = [0]
              __^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_0(x1) = [0] x1 + [0]
              c_1(x1) = [0] x1 + [0]
              c_2(x1) = [0] x1 + [0]
              U11^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_3(x1) = [0] x1 + [0]
              U12^#(x1) = [0] x1 + [0]
              c_4() = [0]
              U21^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_5(x1) = [0] x1 + [0]
              U22^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_6(x1) = [0] x1 + [0]
              U23^#(x1) = [0] x1 + [0]
              c_7() = [0]
              U31^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_8(x1) = [0] x1 + [0]
              U32^#(x1) = [0] x1 + [0]
              c_9() = [0]
              U41^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_10(x1) = [0] x1 + [0]
              U42^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_11(x1) = [0] x1 + [0]
              U43^#(x1) = [0] x1 + [0]
              c_12() = [0]
              U51^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0]
              c_13(x1) = [0] x1 + [0]
              U52^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_14(x1) = [0] x1 + [0]
              U53^#(x1) = [0] x1 + [0]
              c_15() = [0]
              U61^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_16(x1) = [0] x1 + [0]
              U62^#(x1) = [0] x1 + [0]
              c_17() = [0]
              U71^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_18(x1) = [0] x1 + [0]
              U72^#(x1) = [0] x1 + [0]
              c_19() = [0]
              and^#(x1, x2) = [0] x1 + [0] x2 + [0]
              c_20(x1) = [0] x1 + [0]
              isList^#(x1) = [0] x1 + [0]
              c_21(x1) = [0] x1 + [0]
              c_22() = [0]
              c_23(x1) = [0] x1 + [0]
              isNeList^#(x1) = [0] x1 + [0]
              c_24(x1) = [0] x1 + [0]
              c_25(x1) = [0] x1 + [0]
              c_26(x1) = [0] x1 + [0]
              isNePal^#(x1) = [0] x1 + [0]
              c_27(x1) = [0] x1 + [0]
              c_28(x1) = [0] x1 + [0]
              isPal^#(x1) = [0] x1 + [0]
              c_29(x1) = [0] x1 + [0]
              c_30() = [0]
              isPalListKind^#(x1) = [0] x1 + [0]
              c_31() = [0]
              c_32() = [0]
              c_33() = [0]
              c_34() = [0]
              c_35() = [0]
              c_36() = [0]
              c_37(x1) = [0] x1 + [0]
              isQid^#(x1) = [0] x1 + [0]
              c_38() = [0]
              c_39() = [0]
              c_40() = [0]
              c_41() = [0]
              c_42() = [0]
           
           We apply the sub-processor on the resulting sub-problem:
           
           'matrix-interpretation of dimension 1'
           --------------------------------------
           Answer:           YES(?,O(1))
           Input Problem:    DP runtime-complexity with respect to
             Strict Rules: {isQid^#(u()) -> c_42()}
             Weak Rules: {}
           
           Proof Output:    
             The following argument positions are usable:
               Uargs(isQid^#) = {}
             We have the following constructor-restricted matrix interpretation:
             Interpretation Functions:
              u() = [7]
              isQid^#(x1) = [1] x1 + [7]
              c_42() = [1]