/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES We split firstr-order part and higher-order part, and do modular checking by a general modularity. ******** FO SN check ******** Check SN using NaTT (Nagoya Termination Tool) Input TRS: 1: axxu101(tt(),X,Y) -> axxu102(axxisNaturalKind(X),X,Y) 2: axxu102(tt(),U,V) -> axxu103(axxisLNatKind(V),U,V) 3: axxu103(tt(),W,P) -> axxu104(axxisLNatKind(P),W,P) 4: axxu104(tt(),X1,Y1) -> axxu105(axxisNatural(X1),Y1) 5: axxu105(tt(),U1) -> axxu106(axxisLNat(U1)) 6: axxu106(tt()) -> tt() 7: axxu11(tt(),V1,W1) -> axxu12(axxisNaturalKind(V1),V1,W1) 8: axxu111(tt(),P1) -> axxu112(axxisLNatKind(P1)) 9: axxu112(tt()) -> tt() 10: axxu12(tt(),X2,Y2) -> axxu13(axxisLNat(Y2),X2,Y2) 11: axxu121(tt(),U2) -> axxu122(axxisLNatKind(U2)) 12: axxu122(tt()) -> tt() 13: axxu13(tt(),V2,W2) -> axxu14(axxisLNatKind(W2),V2,W2) 14: axxu131(tt()) -> tt() 15: axxu14(tt(),P2,X3) -> axxsnd(axxsplitAt(mark(P2),mark(X3))) 16: axxu141(tt()) -> tt() 17: axxu151(tt()) -> tt() 18: axxu161(tt()) -> tt() 19: axxu171(tt(),Y3) -> axxu172(axxisLNatKind(Y3)) 20: axxu172(tt()) -> tt() 21: axxu181(tt(),U3) -> axxu182(axxisLNatKind(U3),U3) 22: axxu182(tt(),V3) -> axxu183(axxisLNat(V3)) 23: axxu183(tt()) -> tt() 24: axxu191(tt(),W3) -> axxu192(axxisNaturalKind(W3),W3) 25: axxu192(tt(),P3) -> axxu193(axxisNatural(P3)) 26: axxu193(tt()) -> tt() 27: axxu201(tt(),X4,Y4) -> axxu202(axxisNaturalKind(X4),X4,Y4) 28: axxu202(tt(),U4,V4) -> axxu203(axxisLNatKind(V4),U4,V4) 29: axxu203(tt(),W4,P4) -> axxu204(axxisLNatKind(P4),W4,P4) 30: axxu204(tt(),X5,Y5) -> axxu205(axxisNatural(X5),Y5) 31: axxu205(tt(),U5) -> axxu206(axxisLNat(U5)) 32: axxu206(tt()) -> tt() 33: axxu21(tt(),V5,W5) -> axxu22(axxisLNatKind(V5),V5,W5) 34: axxu211(tt()) -> tt() 35: axxu22(tt(),P5,X6) -> axxu23(axxisLNat(X6),P5,X6) 36: axxu221(tt()) -> tt() 37: axxu23(tt(),Y6,U6) -> axxu24(axxisLNatKind(U6),Y6) 38: axxu231(tt(),V6) -> axxu232(axxisLNatKind(V6)) 39: axxu232(tt()) -> tt() 40: axxu24(tt(),W6) -> mark(W6) 41: axxu241(tt(),P6,X7) -> axxu242(axxisLNatKind(P6),P6,X7) 42: axxu242(tt(),Y7,U7) -> axxu243(axxisLNatKind(U7),Y7,U7) 43: axxu243(tt(),V7,W7) -> axxu244(axxisLNatKind(W7),V7,W7) 44: axxu244(tt(),P7,X8) -> axxu245(axxisLNat(P7),X8) 45: axxu245(tt(),Y8) -> axxu246(axxisLNat(Y8)) 46: axxu246(tt()) -> tt() 47: axxu251(tt(),U8,V8) -> axxu252(axxisNaturalKind(U8),U8,V8) 48: axxu252(tt(),W8,P8) -> axxu253(axxisLNatKind(P8),W8,P8) 49: axxu253(tt(),X9,Y9) -> axxu254(axxisLNatKind(Y9),X9,Y9) 50: axxu254(tt(),U9,V9) -> axxu255(axxisNatural(U9),V9) 51: axxu255(tt(),W9) -> axxu256(axxisLNat(W9)) 52: axxu256(tt()) -> tt() 53: axxu261(tt(),P9) -> axxu262(axxisLNatKind(P9)) 54: axxu262(tt()) -> tt() 55: axxu271(tt(),X10) -> axxu272(axxisLNatKind(X10)) 56: axxu272(tt()) -> tt() 57: axxu281(tt(),Y10) -> axxu282(axxisNaturalKind(Y10),Y10) 58: axxu282(tt(),U10) -> cons(mark(U10),natsFrom(s(U10))) 59: axxu291(tt(),V10,W10) -> axxu292(axxisNaturalKind(V10),V10,W10) 60: axxu292(tt(),P10,X11) -> axxu293(axxisLNat(X11),P10,X11) 61: axxu293(tt(),Y11,U11) -> axxu294(axxisLNatKind(U11),Y11,U11) 62: axxu294(tt(),V11,W11) -> axxhead(axxafterNth(mark(V11),mark(W11))) 63: axxu301(tt(),P11,X12) -> axxu302(axxisLNatKind(P11),X12) 64: axxu302(tt(),Y12) -> axxu303(axxisLNat(Y12),Y12) 65: axxu303(tt(),U12) -> axxu304(axxisLNatKind(U12),U12) 66: axxu304(tt(),V12) -> mark(V12) 67: axxu31(tt(),W12,P12) -> axxu32(axxisNaturalKind(W12),W12,P12) 68: axxu311(tt(),X13) -> axxu312(axxisLNatKind(X13),X13) 69: axxu312(tt(),Y13) -> pair(nil(),mark(Y13)) 70: axxu32(tt(),U13,V13) -> axxu33(axxisLNat(V13),U13,V13) 71: axxu321(tt(),W13,P13,X14) -> axxu322(axxisNaturalKind(W13),W13,P13,X14) 72: axxu322(tt(),Y14,U14,V14) -> axxu323(axxisNatural(U14),Y14,U14,V14) 73: axxu323(tt(),W14,P14,X15) -> axxu324(axxisNaturalKind(P14),W14,P14,X15) 74: axxu324(tt(),Y15,U15,V15) -> axxu325(axxisLNat(V15),Y15,U15,V15) 75: axxu325(tt(),W15,P15,X16) -> axxu326(axxisLNatKind(X16),W15,P15,X16) 76: axxu326(tt(),Y16,U16,V16) -> axxu327(axxsplitAt(mark(Y16),mark(V16)),U16) 77: axxu327(pair(W16,P16),X17) -> pair(cons(mark(X17),W16),mark(P16)) 78: axxu33(tt(),Y17,U17) -> axxu34(axxisLNatKind(U17),Y17) 79: axxu331(tt(),V17,W17) -> axxu332(axxisNaturalKind(V17),W17) 80: axxu332(tt(),P17) -> axxu333(axxisLNat(P17),P17) 81: axxu333(tt(),X18) -> axxu334(axxisLNatKind(X18),X18) 82: axxu334(tt(),Y18) -> mark(Y18) 83: axxu34(tt(),U18) -> mark(U18) 84: axxu341(tt(),V18,W18) -> axxu342(axxisNaturalKind(V18),V18,W18) 85: axxu342(tt(),P18,X19) -> axxu343(axxisLNat(X19),P18,X19) 86: axxu343(tt(),Y19,U19) -> axxu344(axxisLNatKind(U19),Y19,U19) 87: axxu344(tt(),V19,W19) -> axxfst(axxsplitAt(mark(V19),mark(W19))) 88: axxu41(tt(),P19,X20) -> axxu42(axxisNaturalKind(P19),P19,X20) 89: axxu42(tt(),Y20,U20) -> axxu43(axxisLNatKind(U20),Y20,U20) 90: axxu43(tt(),V20,W20) -> axxu44(axxisLNatKind(W20),V20,W20) 91: axxu44(tt(),P20,X21) -> axxu45(axxisNatural(P20),X21) 92: axxu45(tt(),Y21) -> axxu46(axxisLNat(Y21)) 93: axxu46(tt()) -> tt() 94: axxu51(tt(),U21,V21) -> axxu52(axxisNaturalKind(U21),U21,V21) 95: axxu52(tt(),W21,P21) -> axxu53(axxisLNatKind(P21),W21,P21) 96: axxu53(tt(),X22,Y22) -> axxu54(axxisLNatKind(Y22),X22,Y22) 97: axxu54(tt(),U22,V22) -> axxu55(axxisNatural(U22),V22) 98: axxu55(tt(),W22) -> axxu56(axxisLNat(W22)) 99: axxu56(tt()) -> tt() 100: axxu61(tt(),P22) -> axxu62(axxisPLNatKind(P22),P22) 101: axxu62(tt(),X23) -> axxu63(axxisPLNat(X23)) 102: axxu63(tt()) -> tt() 103: axxu71(tt(),Y23) -> axxu72(axxisNaturalKind(Y23),Y23) 104: axxu72(tt(),U23) -> axxu73(axxisNatural(U23)) 105: axxu73(tt()) -> tt() 106: axxu81(tt(),V23) -> axxu82(axxisPLNatKind(V23),V23) 107: axxu82(tt(),W23) -> axxu83(axxisPLNat(W23)) 108: axxu83(tt()) -> tt() 109: axxu91(tt(),P23) -> axxu92(axxisLNatKind(P23),P23) 110: axxu92(tt(),X24) -> axxu93(axxisLNat(X24)) 111: axxu93(tt()) -> tt() 112: axxafterNth(Y24,U24) -> axxu11(axxisNatural(Y24),Y24,U24) 113: axxfst(pair(V24,W24)) -> axxu21(axxisLNat(V24),V24,W24) 114: axxhead(cons(P24,X25)) -> axxu31(axxisNatural(P24),P24,X25) 115: axxisLNat(nil()) -> tt() 116: axxisLNat(afterNth(Y25,U25)) -> axxu41(axxisNaturalKind(Y25),Y25,U25) 117: axxisLNat(cons(V25,W25)) -> axxu51(axxisNaturalKind(V25),V25,W25) 118: axxisLNat(fst(P25)) -> axxu61(axxisPLNatKind(P25),P25) 119: axxisLNat(natsFrom(X26)) -> axxu71(axxisNaturalKind(X26),X26) 120: axxisLNat(snd(Y26)) -> axxu81(axxisPLNatKind(Y26),Y26) 121: axxisLNat(tail(U26)) -> axxu91(axxisLNatKind(U26),U26) 122: axxisLNat(take(V26,W26)) -> axxu101(axxisNaturalKind(V26),V26,W26) 123: axxisLNatKind(nil()) -> tt() 124: axxisLNatKind(afterNth(P26,X27)) -> axxu111(axxisNaturalKind(P26),X27) 125: axxisLNatKind(cons(Y27,U27)) -> axxu121(axxisNaturalKind(Y27),U27) 126: axxisLNatKind(fst(V27)) -> axxu131(axxisPLNatKind(V27)) 127: axxisLNatKind(natsFrom(W27)) -> axxu141(axxisNaturalKind(W27)) 128: axxisLNatKind(snd(P27)) -> axxu151(axxisPLNatKind(P27)) 129: axxisLNatKind(tail(X28)) -> axxu161(axxisLNatKind(X28)) 130: axxisLNatKind(take(Y28,U28)) -> axxu171(axxisNaturalKind(Y28),U28) 131: axxisNatural(0()) -> tt() 132: axxisNatural(head(V28)) -> axxu181(axxisLNatKind(V28),V28) 133: axxisNatural(s(W28)) -> axxu191(axxisNaturalKind(W28),W28) 134: axxisNatural(sel(P28,X29)) -> axxu201(axxisNaturalKind(P28),P28,X29) 135: axxisNaturalKind(0()) -> tt() 136: axxisNaturalKind(head(Y29)) -> axxu211(axxisLNatKind(Y29)) 137: axxisNaturalKind(s(U29)) -> axxu221(axxisNaturalKind(U29)) 138: axxisNaturalKind(sel(V29,W29)) -> axxu231(axxisNaturalKind(V29),W29) 139: axxisPLNat(pair(P29,X30)) -> axxu241(axxisLNatKind(P29),P29,X30) 140: axxisPLNat(splitAt(Y30,U30)) -> axxu251(axxisNaturalKind(Y30),Y30,U30) 141: axxisPLNatKind(pair(V30,W30)) -> axxu261(axxisLNatKind(V30),W30) 142: axxisPLNatKind(splitAt(P30,X31)) -> axxu271(axxisNaturalKind(P30),X31) 143: axxnatsFrom(Y31) -> axxu281(axxisNatural(Y31),Y31) 144: axxsel(U31,V31) -> axxu291(axxisNatural(U31),U31,V31) 145: axxsnd(pair(W31,P31)) -> axxu301(axxisLNat(W31),W31,P31) 146: axxsplitAt(0(),X32) -> axxu311(axxisLNat(X32),X32) 147: axxsplitAt(s(Y32),cons(U32,V32)) -> axxu321(axxisNatural(Y32),Y32,U32,V32) 148: axxtail(cons(W32,P32)) -> axxu331(axxisNatural(W32),W32,P32) 149: axxtake(X33,Y33) -> axxu341(axxisNatural(X33),X33,Y33) 150: mark(u101(U33,V33,W33)) -> axxu101(mark(U33),V33,W33) 151: mark(u102(P33,X34,Y34)) -> axxu102(mark(P33),X34,Y34) 152: mark(isNaturalKind(U34)) -> axxisNaturalKind(U34) 153: mark(u103(V34,W34,P34)) -> axxu103(mark(V34),W34,P34) 154: mark(isLNatKind(X35)) -> axxisLNatKind(X35) 155: mark(u104(Y35,U35,V35)) -> axxu104(mark(Y35),U35,V35) 156: mark(u105(W35,P35)) -> axxu105(mark(W35),P35) 157: mark(isNatural(X36)) -> axxisNatural(X36) 158: mark(u106(Y36)) -> axxu106(mark(Y36)) 159: mark(isLNat(U36)) -> axxisLNat(U36) 160: mark(u11(V36,W36,P36)) -> axxu11(mark(V36),W36,P36) 161: mark(u12(X37,Y37,U37)) -> axxu12(mark(X37),Y37,U37) 162: mark(u111(V37,W37)) -> axxu111(mark(V37),W37) 163: mark(u112(P37)) -> axxu112(mark(P37)) 164: mark(u13(X38,Y38,U38)) -> axxu13(mark(X38),Y38,U38) 165: mark(u121(V38,W38)) -> axxu121(mark(V38),W38) 166: mark(u122(P38)) -> axxu122(mark(P38)) 167: mark(u14(X39,Y39,U39)) -> axxu14(mark(X39),Y39,U39) 168: mark(u131(V39)) -> axxu131(mark(V39)) 169: mark(snd(W39)) -> axxsnd(mark(W39)) 170: mark(splitAt(P39,X40)) -> axxsplitAt(mark(P39),mark(X40)) 171: mark(u141(Y40)) -> axxu141(mark(Y40)) 172: mark(u151(U40)) -> axxu151(mark(U40)) 173: mark(u161(V40)) -> axxu161(mark(V40)) 174: mark(u171(W40,P40)) -> axxu171(mark(W40),P40) 175: mark(u172(X41)) -> axxu172(mark(X41)) 176: mark(u181(Y41,U41)) -> axxu181(mark(Y41),U41) 177: mark(u182(V41,W41)) -> axxu182(mark(V41),W41) 178: mark(u183(P41)) -> axxu183(mark(P41)) 179: mark(u191(X42,Y42)) -> axxu191(mark(X42),Y42) 180: mark(u192(U42,V42)) -> axxu192(mark(U42),V42) 181: mark(u193(W42)) -> axxu193(mark(W42)) 182: mark(u201(P42,X43,Y43)) -> axxu201(mark(P42),X43,Y43) 183: mark(u202(U43,V43,W43)) -> axxu202(mark(U43),V43,W43) 184: mark(u203(P43,X44,Y44)) -> axxu203(mark(P43),X44,Y44) 185: mark(u204(U44,V44,W44)) -> axxu204(mark(U44),V44,W44) 186: mark(u205(P44,X45)) -> axxu205(mark(P44),X45) 187: mark(u206(Y45)) -> axxu206(mark(Y45)) 188: mark(u21(U45,V45,W45)) -> axxu21(mark(U45),V45,W45) 189: mark(u22(P45,X46,Y46)) -> axxu22(mark(P45),X46,Y46) 190: mark(u211(U46)) -> axxu211(mark(U46)) 191: mark(u23(V46,W46,P46)) -> axxu23(mark(V46),W46,P46) 192: mark(u221(X47)) -> axxu221(mark(X47)) 193: mark(u24(Y47,U47)) -> axxu24(mark(Y47),U47) 194: mark(u231(V47,W47)) -> axxu231(mark(V47),W47) 195: mark(u232(P47)) -> axxu232(mark(P47)) 196: mark(u241(X48,Y48,U48)) -> axxu241(mark(X48),Y48,U48) 197: mark(u242(V48,W48,P48)) -> axxu242(mark(V48),W48,P48) 198: mark(u243(X49,Y49,U49)) -> axxu243(mark(X49),Y49,U49) 199: mark(u244(V49,W49,P49)) -> axxu244(mark(V49),W49,P49) 200: mark(u245(X50,Y50)) -> axxu245(mark(X50),Y50) 201: mark(u246(U50)) -> axxu246(mark(U50)) 202: mark(u251(V50,W50,P50)) -> axxu251(mark(V50),W50,P50) 203: mark(u252(X51,Y51,U51)) -> axxu252(mark(X51),Y51,U51) 204: mark(u253(V51,W51,P51)) -> axxu253(mark(V51),W51,P51) 205: mark(u254(X52,Y52,U52)) -> axxu254(mark(X52),Y52,U52) 206: mark(u255(V52,W52)) -> axxu255(mark(V52),W52) 207: mark(u256(P52)) -> axxu256(mark(P52)) 208: mark(u261(X53,Y53)) -> axxu261(mark(X53),Y53) 209: mark(u262(U53)) -> axxu262(mark(U53)) 210: mark(u271(V53,W53)) -> axxu271(mark(V53),W53) 211: mark(u272(P53)) -> axxu272(mark(P53)) 212: mark(u281(X54,Y54)) -> axxu281(mark(X54),Y54) 213: mark(u282(U54,V54)) -> axxu282(mark(U54),V54) 214: mark(natsFrom(W54)) -> axxnatsFrom(mark(W54)) 215: mark(u291(P54,X55,Y55)) -> axxu291(mark(P54),X55,Y55) 216: mark(u292(U55,V55,W55)) -> axxu292(mark(U55),V55,W55) 217: mark(u293(P55,X56,Y56)) -> axxu293(mark(P55),X56,Y56) 218: mark(u294(U56,V56,W56)) -> axxu294(mark(U56),V56,W56) 219: mark(head(P56)) -> axxhead(mark(P56)) 220: mark(afterNth(X57,Y57)) -> axxafterNth(mark(X57),mark(Y57)) 221: mark(u301(U57,V57,W57)) -> axxu301(mark(U57),V57,W57) 222: mark(u302(P57,X58)) -> axxu302(mark(P57),X58) 223: mark(u303(Y58,U58)) -> axxu303(mark(Y58),U58) 224: mark(u304(V58,W58)) -> axxu304(mark(V58),W58) 225: mark(u31(P58,X59,Y59)) -> axxu31(mark(P58),X59,Y59) 226: mark(u32(U59,V59,W59)) -> axxu32(mark(U59),V59,W59) 227: mark(u311(P59,X60)) -> axxu311(mark(P59),X60) 228: mark(u312(Y60,U60)) -> axxu312(mark(Y60),U60) 229: mark(u33(V60,W60,P60)) -> axxu33(mark(V60),W60,P60) 230: mark(u321(X61,Y61,U61,V61)) -> axxu321(mark(X61),Y61,U61,V61) 231: mark(u322(W61,P61,X62,Y62)) -> axxu322(mark(W61),P61,X62,Y62) 232: mark(u323(U62,V62,W62,P62)) -> axxu323(mark(U62),V62,W62,P62) 233: mark(u324(X63,Y63,U63,V63)) -> axxu324(mark(X63),Y63,U63,V63) 234: mark(u325(W63,P63,X64,Y64)) -> axxu325(mark(W63),P63,X64,Y64) 235: mark(u326(U64,V64,W64,P64)) -> axxu326(mark(U64),V64,W64,P64) 236: mark(u327(X65,Y65)) -> axxu327(mark(X65),Y65) 237: mark(u34(U65,V65)) -> axxu34(mark(U65),V65) 238: mark(u331(W65,P65,X66)) -> axxu331(mark(W65),P65,X66) 239: mark(u332(Y66,U66)) -> axxu332(mark(Y66),U66) 240: mark(u333(V66,W66)) -> axxu333(mark(V66),W66) 241: mark(u334(P66,X67)) -> axxu334(mark(P66),X67) 242: mark(u341(Y67,U67,V67)) -> axxu341(mark(Y67),U67,V67) 243: mark(u342(W67,P67,X68)) -> axxu342(mark(W67),P67,X68) 244: mark(u343(Y68,U68,V68)) -> axxu343(mark(Y68),U68,V68) 245: mark(u344(W68,P68,X69)) -> axxu344(mark(W68),P68,X69) 246: mark(fst(Y69)) -> axxfst(mark(Y69)) 247: mark(u41(U69,V69,W69)) -> axxu41(mark(U69),V69,W69) 248: mark(u42(P69,X70,Y70)) -> axxu42(mark(P69),X70,Y70) 249: mark(u43(U70,V70,W70)) -> axxu43(mark(U70),V70,W70) 250: mark(u44(P70,X71,Y71)) -> axxu44(mark(P70),X71,Y71) 251: mark(u45(U71,V71)) -> axxu45(mark(U71),V71) 252: mark(u46(W71)) -> axxu46(mark(W71)) 253: mark(u51(P71,X72,Y72)) -> axxu51(mark(P71),X72,Y72) 254: mark(u52(U72,V72,W72)) -> axxu52(mark(U72),V72,W72) 255: mark(u53(P72,X73,Y73)) -> axxu53(mark(P72),X73,Y73) 256: mark(u54(U73,V73,W73)) -> axxu54(mark(U73),V73,W73) 257: mark(u55(P73,X74)) -> axxu55(mark(P73),X74) 258: mark(u56(Y74)) -> axxu56(mark(Y74)) 259: mark(u61(U74,V74)) -> axxu61(mark(U74),V74) 260: mark(u62(W74,P74)) -> axxu62(mark(W74),P74) 261: mark(isPLNatKind(X75)) -> axxisPLNatKind(X75) 262: mark(u63(Y75)) -> axxu63(mark(Y75)) 263: mark(isPLNat(U75)) -> axxisPLNat(U75) 264: mark(u71(V75,W75)) -> axxu71(mark(V75),W75) 265: mark(u72(P75,X76)) -> axxu72(mark(P75),X76) 266: mark(u73(Y76)) -> axxu73(mark(Y76)) 267: mark(u81(U76,V76)) -> axxu81(mark(U76),V76) 268: mark(u82(W76,P76)) -> axxu82(mark(W76),P76) 269: mark(u83(X77)) -> axxu83(mark(X77)) 270: mark(u91(Y77,U77)) -> axxu91(mark(Y77),U77) 271: mark(u92(V77,W77)) -> axxu92(mark(V77),W77) 272: mark(u93(P77)) -> axxu93(mark(P77)) 273: mark(tail(X78)) -> axxtail(mark(X78)) 274: mark(take(Y78,U78)) -> axxtake(mark(Y78),mark(U78)) 275: mark(sel(V78,W78)) -> axxsel(mark(V78),mark(W78)) 276: mark(tt()) -> tt() 277: mark(cons(P78,X79)) -> cons(mark(P78),X79) 278: mark(s(Y79)) -> s(mark(Y79)) 279: mark(pair(U79,V79)) -> pair(mark(U79),mark(V79)) 280: mark(nil()) -> nil() 281: mark(0()) -> 0() 282: axxu101(W79,P79,X80) -> u101(W79,P79,X80) 283: axxu102(Y80,U80,V80) -> u102(Y80,U80,V80) 284: axxisNaturalKind(W80) -> isNaturalKind(W80) 285: axxu103(P80,X81,Y81) -> u103(P80,X81,Y81) 286: axxisLNatKind(U81) -> isLNatKind(U81) 287: axxu104(V81,W81,P81) -> u104(V81,W81,P81) 288: axxu105(X82,Y82) -> u105(X82,Y82) 289: axxisNatural(U82) -> isNatural(U82) 290: axxu106(V82) -> u106(V82) 291: axxisLNat(W82) -> isLNat(W82) 292: axxu11(P82,X83,Y83) -> u11(P82,X83,Y83) 293: axxu12(U83,V83,W83) -> u12(U83,V83,W83) 294: axxu111(P83,X84) -> u111(P83,X84) 295: axxu112(Y84) -> u112(Y84) 296: axxu13(U84,V84,W84) -> u13(U84,V84,W84) 297: axxu121(P84,X85) -> u121(P84,X85) 298: axxu122(Y85) -> u122(Y85) 299: axxu14(U85,V85,W85) -> u14(U85,V85,W85) 300: axxu131(P85) -> u131(P85) 301: axxsnd(X86) -> snd(X86) 302: axxsplitAt(Y86,U86) -> splitAt(Y86,U86) 303: axxu141(V86) -> u141(V86) 304: axxu151(W86) -> u151(W86) 305: axxu161(P86) -> u161(P86) 306: axxu171(X87,Y87) -> u171(X87,Y87) 307: axxu172(U87) -> u172(U87) 308: axxu181(V87,W87) -> u181(V87,W87) 309: axxu182(P87,X88) -> u182(P87,X88) 310: axxu183(Y88) -> u183(Y88) 311: axxu191(U88,V88) -> u191(U88,V88) 312: axxu192(W88,P88) -> u192(W88,P88) 313: axxu193(X89) -> u193(X89) 314: axxu201(Y89,U89,V89) -> u201(Y89,U89,V89) 315: axxu202(W89,P89,X90) -> u202(W89,P89,X90) 316: axxu203(Y90,U90,V90) -> u203(Y90,U90,V90) 317: axxu204(W90,P90,X91) -> u204(W90,P90,X91) 318: axxu205(Y91,U91) -> u205(Y91,U91) 319: axxu206(V91) -> u206(V91) 320: axxu21(W91,P91,X92) -> u21(W91,P91,X92) 321: axxu22(Y92,U92,V92) -> u22(Y92,U92,V92) 322: axxu211(W92) -> u211(W92) 323: axxu23(P92,X93,Y93) -> u23(P92,X93,Y93) 324: axxu221(U93) -> u221(U93) 325: axxu24(V93,W93) -> u24(V93,W93) 326: axxu231(P93,X94) -> u231(P93,X94) 327: axxu232(Y94) -> u232(Y94) 328: axxu241(U94,V94,W94) -> u241(U94,V94,W94) 329: axxu242(P94,X95,Y95) -> u242(P94,X95,Y95) 330: axxu243(U95,V95,W95) -> u243(U95,V95,W95) 331: axxu244(P95,X96,Y96) -> u244(P95,X96,Y96) 332: axxu245(U96,V96) -> u245(U96,V96) 333: axxu246(W96) -> u246(W96) 334: axxu251(P96,X97,Y97) -> u251(P96,X97,Y97) 335: axxu252(U97,V97,W97) -> u252(U97,V97,W97) 336: axxu253(P97,X98,Y98) -> u253(P97,X98,Y98) 337: axxu254(U98,V98,W98) -> u254(U98,V98,W98) 338: axxu255(P98,X99) -> u255(P98,X99) 339: axxu256(Y99) -> u256(Y99) 340: axxu261(U99,V99) -> u261(U99,V99) 341: axxu262(W99) -> u262(W99) 342: axxu271(P99,X100) -> u271(P99,X100) 343: axxu272(Y100) -> u272(Y100) 344: axxu281(U100,V100) -> u281(U100,V100) 345: axxu282(W100,P100) -> u282(W100,P100) 346: axxnatsFrom(X101) -> natsFrom(X101) 347: axxu291(Y101,U101,V101) -> u291(Y101,U101,V101) 348: axxu292(W101,P101,X102) -> u292(W101,P101,X102) 349: axxu293(Y102,U102,V102) -> u293(Y102,U102,V102) 350: axxu294(W102,P102,X103) -> u294(W102,P102,X103) 351: axxhead(Y103) -> head(Y103) 352: axxafterNth(U103,V103) -> afterNth(U103,V103) 353: axxu301(W103,P103,X104) -> u301(W103,P103,X104) 354: axxu302(Y104,U104) -> u302(Y104,U104) 355: axxu303(V104,W104) -> u303(V104,W104) 356: axxu304(P104,X105) -> u304(P104,X105) 357: axxu31(Y105,U105,V105) -> u31(Y105,U105,V105) 358: axxu32(W105,P105,X106) -> u32(W105,P105,X106) 359: axxu311(Y106,U106) -> u311(Y106,U106) 360: axxu312(V106,W106) -> u312(V106,W106) 361: axxu33(P106,X107,Y107) -> u33(P106,X107,Y107) 362: axxu321(U107,V107,W107,P107) -> u321(U107,V107,W107,P107) 363: axxu322(X108,Y108,U108,V108) -> u322(X108,Y108,U108,V108) 364: axxu323(W108,P108,X109,Y109) -> u323(W108,P108,X109,Y109) 365: axxu324(U109,V109,W109,P109) -> u324(U109,V109,W109,P109) 366: axxu325(X110,Y110,U110,V110) -> u325(X110,Y110,U110,V110) 367: axxu326(W110,P110,X111,Y111) -> u326(W110,P110,X111,Y111) 368: axxu327(U111,V111) -> u327(U111,V111) 369: axxu34(W111,P111) -> u34(W111,P111) 370: axxu331(X112,Y112,U112) -> u331(X112,Y112,U112) 371: axxu332(V112,W112) -> u332(V112,W112) 372: axxu333(P112,X113) -> u333(P112,X113) 373: axxu334(Y113,U113) -> u334(Y113,U113) 374: axxu341(V113,W113,P113) -> u341(V113,W113,P113) 375: axxu342(X114,Y114,U114) -> u342(X114,Y114,U114) 376: axxu343(V114,W114,P114) -> u343(V114,W114,P114) 377: axxu344(X115,Y115,U115) -> u344(X115,Y115,U115) 378: axxfst(V115) -> fst(V115) 379: axxu41(W115,P115,X116) -> u41(W115,P115,X116) 380: axxu42(Y116,U116,V116) -> u42(Y116,U116,V116) 381: axxu43(W116,P116,X117) -> u43(W116,P116,X117) 382: axxu44(Y117,U117,V117) -> u44(Y117,U117,V117) 383: axxu45(W117,P117) -> u45(W117,P117) 384: axxu46(X118) -> u46(X118) 385: axxu51(Y118,U118,V118) -> u51(Y118,U118,V118) 386: axxu52(W118,P118,X119) -> u52(W118,P118,X119) 387: axxu53(Y119,U119,V119) -> u53(Y119,U119,V119) 388: axxu54(W119,P119,X120) -> u54(W119,P119,X120) 389: axxu55(Y120,U120) -> u55(Y120,U120) 390: axxu56(V120) -> u56(V120) 391: axxu61(W120,P120) -> u61(W120,P120) 392: axxu62(X121,Y121) -> u62(X121,Y121) 393: axxisPLNatKind(U121) -> isPLNatKind(U121) 394: axxu63(V121) -> u63(V121) 395: axxisPLNat(W121) -> isPLNat(W121) 396: axxu71(P121,X122) -> u71(P121,X122) 397: axxu72(Y122,U122) -> u72(Y122,U122) 398: axxu73(V122) -> u73(V122) 399: axxu81(W122,P122) -> u81(W122,P122) 400: axxu82(X123,Y123) -> u82(X123,Y123) 401: axxu83(U123) -> u83(U123) 402: axxu91(V123,W123) -> u91(V123,W123) 403: axxu92(P123,X124) -> u92(P123,X124) 404: axxu93(Y124) -> u93(Y124) 405: axxtail(U124) -> tail(U124) 406: axxtake(V124,W124) -> take(V124,W124) 407: axxsel(P124,X125) -> sel(P124,X125) 408: _(X1,X2) -> X1 409: _(X1,X2) -> X2 Number of strict rules: 409 Direct POLO(bPol) ... failed. Uncurrying ... failed. Dependency Pairs: #1: #axxu102(tt(),U,V) -> #axxu103(axxisLNatKind(V),U,V) #2: #axxu102(tt(),U,V) -> #axxisLNatKind(V) #3: #axxu343(tt(),Y19,U19) -> #axxu344(axxisLNatKind(U19),Y19,U19) #4: #axxu343(tt(),Y19,U19) -> #axxisLNatKind(U19) #5: #axxu243(tt(),V7,W7) -> #axxu244(axxisLNatKind(W7),V7,W7) #6: #axxu243(tt(),V7,W7) -> #axxisLNatKind(W7) #7: #axxu203(tt(),W4,P4) -> #axxu204(axxisLNatKind(P4),W4,P4) #8: #axxu203(tt(),W4,P4) -> #axxisLNatKind(P4) #9: #mark(u331(W65,P65,X66)) -> #axxu331(mark(W65),P65,X66) #10: #mark(u331(W65,P65,X66)) -> #mark(W65) #11: #mark(isPLNat(U75)) -> #axxisPLNat(U75) #12: #axxu22(tt(),P5,X6) -> #axxu23(axxisLNat(X6),P5,X6) #13: #axxu22(tt(),P5,X6) -> #axxisLNat(X6) #14: #axxu34(tt(),U18) -> #mark(U18) #15: #axxu304(tt(),V12) -> #mark(V12) #16: #mark(u182(V41,W41)) -> #axxu182(mark(V41),W41) #17: #mark(u182(V41,W41)) -> #mark(V41) #18: #mark(u33(V60,W60,P60)) -> #axxu33(mark(V60),W60,P60) #19: #mark(u33(V60,W60,P60)) -> #mark(V60) #20: #mark(u51(P71,X72,Y72)) -> #axxu51(mark(P71),X72,Y72) #21: #mark(u51(P71,X72,Y72)) -> #mark(P71) #22: #axxu242(tt(),Y7,U7) -> #axxu243(axxisLNatKind(U7),Y7,U7) #23: #axxu242(tt(),Y7,U7) -> #axxisLNatKind(U7) #24: #mark(u323(U62,V62,W62,P62)) -> #axxu323(mark(U62),V62,W62,P62) #25: #mark(u323(U62,V62,W62,P62)) -> #mark(U62) #26: #mark(u243(X49,Y49,U49)) -> #axxu243(mark(X49),Y49,U49) #27: #mark(u243(X49,Y49,U49)) -> #mark(X49) #28: #axxtake(X33,Y33) -> #axxu341(axxisNatural(X33),X33,Y33) #29: #axxtake(X33,Y33) -> #axxisNatural(X33) #30: #axxu52(tt(),W21,P21) -> #axxu53(axxisLNatKind(P21),W21,P21) #31: #axxu52(tt(),W21,P21) -> #axxisLNatKind(P21) #32: #axxu241(tt(),P6,X7) -> #axxu242(axxisLNatKind(P6),P6,X7) #33: #axxu241(tt(),P6,X7) -> #axxisLNatKind(P6) #34: #mark(u42(P69,X70,Y70)) -> #axxu42(mark(P69),X70,Y70) #35: #mark(u42(P69,X70,Y70)) -> #mark(P69) #36: #mark(u72(P75,X76)) -> #axxu72(mark(P75),X76) #37: #mark(u72(P75,X76)) -> #mark(P75) #38: #mark(u46(W71)) -> #axxu46(mark(W71)) #39: #mark(u46(W71)) -> #mark(W71) #40: #axxu23(tt(),Y6,U6) -> #axxu24(axxisLNatKind(U6),Y6) #41: #axxu23(tt(),Y6,U6) -> #axxisLNatKind(U6) #42: #axxhead(cons(P24,X25)) -> #axxu31(axxisNatural(P24),P24,X25) #43: #axxhead(cons(P24,X25)) -> #axxisNatural(P24) #44: #mark(u321(X61,Y61,U61,V61)) -> #axxu321(mark(X61),Y61,U61,V61) #45: #mark(u321(X61,Y61,U61,V61)) -> #mark(X61) #46: #mark(u112(P37)) -> #axxu112(mark(P37)) #47: #mark(u112(P37)) -> #mark(P37) #48: #axxu54(tt(),U22,V22) -> #axxu55(axxisNatural(U22),V22) #49: #axxu54(tt(),U22,V22) -> #axxisNatural(U22) #50: #axxu44(tt(),P20,X21) -> #axxu45(axxisNatural(P20),X21) #51: #axxu44(tt(),P20,X21) -> #axxisNatural(P20) #52: #axxu323(tt(),W14,P14,X15) -> #axxu324(axxisNaturalKind(P14),W14,P14,X15) #53: #axxu323(tt(),W14,P14,X15) -> #axxisNaturalKind(P14) #54: #axxu251(tt(),U8,V8) -> #axxu252(axxisNaturalKind(U8),U8,V8) #55: #axxu251(tt(),U8,V8) -> #axxisNaturalKind(U8) #56: #mark(u294(U56,V56,W56)) -> #axxu294(mark(U56),V56,W56) #57: #mark(u294(U56,V56,W56)) -> #mark(U56) #58: #mark(u23(V46,W46,P46)) -> #axxu23(mark(V46),W46,P46) #59: #mark(u23(V46,W46,P46)) -> #mark(V46) #60: #mark(u333(V66,W66)) -> #axxu333(mark(V66),W66) #61: #mark(u333(V66,W66)) -> #mark(V66) #62: #axxu261(tt(),P9) -> #axxu262(axxisLNatKind(P9)) #63: #axxu261(tt(),P9) -> #axxisLNatKind(P9) #64: #mark(u62(W74,P74)) -> #axxu62(mark(W74),P74) #65: #mark(u62(W74,P74)) -> #mark(W74) #66: #mark(u161(V40)) -> #axxu161(mark(V40)) #67: #mark(u161(V40)) -> #mark(V40) #68: #mark(u325(W63,P63,X64,Y64)) -> #axxu325(mark(W63),P63,X64,Y64) #69: #mark(u325(W63,P63,X64,Y64)) -> #mark(W63) #70: #axxu321(tt(),W13,P13,X14) -> #axxu322(axxisNaturalKind(W13),W13,P13,X14) #71: #axxu321(tt(),W13,P13,X14) -> #axxisNaturalKind(W13) #72: #axxsplitAt(s(Y32),cons(U32,V32)) -> #axxu321(axxisNatural(Y32),Y32,U32,V32) #73: #axxsplitAt(s(Y32),cons(U32,V32)) -> #axxisNatural(Y32) #74: #axxisPLNat(pair(P29,X30)) -> #axxu241(axxisLNatKind(P29),P29,X30) #75: #axxisPLNat(pair(P29,X30)) -> #axxisLNatKind(P29) #76: #axxu252(tt(),W8,P8) -> #axxu253(axxisLNatKind(P8),W8,P8) #77: #axxu252(tt(),W8,P8) -> #axxisLNatKind(P8) #78: #mark(u81(U76,V76)) -> #axxu81(mark(U76),V76) #79: #mark(u81(U76,V76)) -> #mark(U76) #80: #axxu325(tt(),W15,P15,X16) -> #axxu326(axxisLNatKind(X16),W15,P15,X16) #81: #axxu325(tt(),W15,P15,X16) -> #axxisLNatKind(X16) #82: #mark(u53(P72,X73,Y73)) -> #axxu53(mark(P72),X73,Y73) #83: #mark(u53(P72,X73,Y73)) -> #mark(P72) #84: #mark(u183(P41)) -> #axxu183(mark(P41)) #85: #mark(u183(P41)) -> #mark(P41) #86: #axxafterNth(Y24,U24) -> #axxu11(axxisNatural(Y24),Y24,U24) #87: #axxafterNth(Y24,U24) -> #axxisNatural(Y24) #88: #axxu324(tt(),Y15,U15,V15) -> #axxu325(axxisLNat(V15),Y15,U15,V15) #89: #axxu324(tt(),Y15,U15,V15) -> #axxisLNat(V15) #90: #mark(splitAt(P39,X40)) -> #axxsplitAt(mark(P39),mark(X40)) #91: #mark(splitAt(P39,X40)) -> #mark(P39) #92: #mark(splitAt(P39,X40)) -> #mark(X40) #93: #axxu282(tt(),U10) -> #mark(U10) #94: #mark(s(Y79)) -> #mark(Y79) #95: #mark(u54(U73,V73,W73)) -> #axxu54(mark(U73),V73,W73) #96: #mark(u54(U73,V73,W73)) -> #mark(U73) #97: #axxisNaturalKind(sel(V29,W29)) -> #axxu231(axxisNaturalKind(V29),W29) #98: #axxisNaturalKind(sel(V29,W29)) -> #axxisNaturalKind(V29) #99: #axxfst(pair(V24,W24)) -> #axxu21(axxisLNat(V24),V24,W24) #100: #axxfst(pair(V24,W24)) -> #axxisLNat(V24) #101: #mark(u106(Y36)) -> #axxu106(mark(Y36)) #102: #mark(u106(Y36)) -> #mark(Y36) #103: #axxu293(tt(),Y11,U11) -> #axxu294(axxisLNatKind(U11),Y11,U11) #104: #axxu293(tt(),Y11,U11) -> #axxisLNatKind(U11) #105: #axxu231(tt(),V6) -> #axxu232(axxisLNatKind(V6)) #106: #axxu231(tt(),V6) -> #axxisLNatKind(V6) #107: #mark(u102(P33,X34,Y34)) -> #axxu102(mark(P33),X34,Y34) #108: #mark(u102(P33,X34,Y34)) -> #mark(P33) #109: #mark(isLNatKind(X35)) -> #axxisLNatKind(X35) #110: #axxisLNat(afterNth(Y25,U25)) -> #axxu41(axxisNaturalKind(Y25),Y25,U25) #111: #axxisLNat(afterNth(Y25,U25)) -> #axxisNaturalKind(Y25) #112: #mark(u104(Y35,U35,V35)) -> #axxu104(mark(Y35),U35,V35) #113: #mark(u104(Y35,U35,V35)) -> #mark(Y35) #114: #mark(u303(Y58,U58)) -> #axxu303(mark(Y58),U58) #115: #mark(u303(Y58,U58)) -> #mark(Y58) #116: #mark(u241(X48,Y48,U48)) -> #axxu241(mark(X48),Y48,U48) #117: #mark(u241(X48,Y48,U48)) -> #mark(X48) #118: #mark(u121(V38,W38)) -> #axxu121(mark(V38),W38) #119: #mark(u121(V38,W38)) -> #mark(V38) #120: #axxu291(tt(),V10,W10) -> #axxu292(axxisNaturalKind(V10),V10,W10) #121: #axxu291(tt(),V10,W10) -> #axxisNaturalKind(V10) #122: #mark(u24(Y47,U47)) -> #axxu24(mark(Y47),U47) #123: #mark(u24(Y47,U47)) -> #mark(Y47) #124: #axxu92(tt(),X24) -> #axxu93(axxisLNat(X24)) #125: #axxu92(tt(),X24) -> #axxisLNat(X24) #126: #axxisNatural(head(V28)) -> #axxu181(axxisLNatKind(V28),V28) #127: #axxisNatural(head(V28)) -> #axxisLNatKind(V28) #128: #axxu271(tt(),X10) -> #axxu272(axxisLNatKind(X10)) #129: #axxu271(tt(),X10) -> #axxisLNatKind(X10) #130: #axxu31(tt(),W12,P12) -> #axxu32(axxisNaturalKind(W12),W12,P12) #131: #axxu31(tt(),W12,P12) -> #axxisNaturalKind(W12) #132: #mark(u271(V53,W53)) -> #axxu271(mark(V53),W53) #133: #mark(u271(V53,W53)) -> #mark(V53) #134: #axxu24(tt(),W6) -> #mark(W6) #135: #mark(u82(W76,P76)) -> #axxu82(mark(W76),P76) #136: #mark(u82(W76,P76)) -> #mark(W76) #137: #axxu43(tt(),V20,W20) -> #axxu44(axxisLNatKind(W20),V20,W20) #138: #axxu43(tt(),V20,W20) -> #axxisLNatKind(W20) #139: #mark(u43(U70,V70,W70)) -> #axxu43(mark(U70),V70,W70) #140: #mark(u43(U70,V70,W70)) -> #mark(U70) #141: #axxsplitAt(0(),X32) -> #axxu311(axxisLNat(X32),X32) #142: #axxsplitAt(0(),X32) -> #axxisLNat(X32) #143: #axxu82(tt(),W23) -> #axxu83(axxisPLNat(W23)) #144: #axxu82(tt(),W23) -> #axxisPLNat(W23) #145: #axxu255(tt(),W9) -> #axxu256(axxisLNat(W9)) #146: #axxu255(tt(),W9) -> #axxisLNat(W9) #147: #mark(afterNth(X57,Y57)) -> #axxafterNth(mark(X57),mark(Y57)) #148: #mark(afterNth(X57,Y57)) -> #mark(X57) #149: #mark(afterNth(X57,Y57)) -> #mark(Y57) #150: #axxu13(tt(),V2,W2) -> #axxu14(axxisLNatKind(W2),V2,W2) #151: #axxu13(tt(),V2,W2) -> #axxisLNatKind(W2) #152: #mark(u251(V50,W50,P50)) -> #axxu251(mark(V50),W50,P50) #153: #mark(u251(V50,W50,P50)) -> #mark(V50) #154: #axxu121(tt(),U2) -> #axxu122(axxisLNatKind(U2)) #155: #axxu121(tt(),U2) -> #axxisLNatKind(U2) #156: #mark(natsFrom(W54)) -> #axxnatsFrom(mark(W54)) #157: #mark(natsFrom(W54)) -> #mark(W54) #158: #axxu55(tt(),W22) -> #axxu56(axxisLNat(W22)) #159: #axxu55(tt(),W22) -> #axxisLNat(W22) #160: #mark(u55(P73,X74)) -> #axxu55(mark(P73),X74) #161: #mark(u55(P73,X74)) -> #mark(P73) #162: #mark(u105(W35,P35)) -> #axxu105(mark(W35),P35) #163: #mark(u105(W35,P35)) -> #mark(W35) #164: #axxu281(tt(),Y10) -> #axxu282(axxisNaturalKind(Y10),Y10) #165: #axxu281(tt(),Y10) -> #axxisNaturalKind(Y10) #166: #mark(u344(W68,P68,X69)) -> #axxu344(mark(W68),P68,X69) #167: #mark(u344(W68,P68,X69)) -> #mark(W68) #168: #mark(u242(V48,W48,P48)) -> #axxu242(mark(V48),W48,P48) #169: #mark(u242(V48,W48,P48)) -> #mark(V48) #170: #axxu326(tt(),Y16,U16,V16) -> #axxu327(axxsplitAt(mark(Y16),mark(V16)),U16) #171: #axxu326(tt(),Y16,U16,V16) -> #axxsplitAt(mark(Y16),mark(V16)) #172: #axxu326(tt(),Y16,U16,V16) -> #mark(Y16) #173: #axxu326(tt(),Y16,U16,V16) -> #mark(V16) #174: #mark(u14(X39,Y39,U39)) -> #axxu14(mark(X39),Y39,U39) #175: #mark(u14(X39,Y39,U39)) -> #mark(X39) #176: #mark(u211(U46)) -> #axxu211(mark(U46)) #177: #mark(u211(U46)) -> #mark(U46) #178: #axxu91(tt(),P23) -> #axxu92(axxisLNatKind(P23),P23) #179: #axxu91(tt(),P23) -> #axxisLNatKind(P23) #180: #axxu51(tt(),U21,V21) -> #axxu52(axxisNaturalKind(U21),U21,V21) #181: #axxu51(tt(),U21,V21) -> #axxisNaturalKind(U21) #182: #axxu191(tt(),W3) -> #axxu192(axxisNaturalKind(W3),W3) #183: #axxu191(tt(),W3) -> #axxisNaturalKind(W3) #184: #axxisNatural(sel(P28,X29)) -> #axxu201(axxisNaturalKind(P28),P28,X29) #185: #axxisNatural(sel(P28,X29)) -> #axxisNaturalKind(P28) #186: #axxu32(tt(),U13,V13) -> #axxu33(axxisLNat(V13),U13,V13) #187: #axxu32(tt(),U13,V13) -> #axxisLNat(V13) #188: #mark(tail(X78)) -> #axxtail(mark(X78)) #189: #mark(tail(X78)) -> #mark(X78) #190: #mark(u327(X65,Y65)) -> #axxu327(mark(X65),Y65) #191: #mark(u327(X65,Y65)) -> #mark(X65) #192: #axxisLNatKind(snd(P27)) -> #axxu151(axxisPLNatKind(P27)) #193: #axxisLNatKind(snd(P27)) -> #axxisPLNatKind(P27) #194: #axxu333(tt(),X18) -> #axxu334(axxisLNatKind(X18),X18) #195: #axxu333(tt(),X18) -> #axxisLNatKind(X18) #196: #axxisLNat(fst(P25)) -> #axxu61(axxisPLNatKind(P25),P25) #197: #axxisLNat(fst(P25)) -> #axxisPLNatKind(P25) #198: #axxu33(tt(),Y17,U17) -> #axxu34(axxisLNatKind(U17),Y17) #199: #axxu33(tt(),Y17,U17) -> #axxisLNatKind(U17) #200: #axxu245(tt(),Y8) -> #axxu246(axxisLNat(Y8)) #201: #axxu245(tt(),Y8) -> #axxisLNat(Y8) #202: #axxu53(tt(),X22,Y22) -> #axxu54(axxisLNatKind(Y22),X22,Y22) #203: #axxu53(tt(),X22,Y22) -> #axxisLNatKind(Y22) #204: #mark(u252(X51,Y51,U51)) -> #axxu252(mark(X51),Y51,U51) #205: #mark(u252(X51,Y51,U51)) -> #mark(X51) #206: #mark(u246(U50)) -> #axxu246(mark(U50)) #207: #mark(u246(U50)) -> #mark(U50) #208: #axxu312(tt(),Y13) -> #mark(Y13) #209: #mark(u262(U53)) -> #axxu262(mark(U53)) #210: #mark(u262(U53)) -> #mark(U53) #211: #axxu62(tt(),X23) -> #axxu63(axxisPLNat(X23)) #212: #axxu62(tt(),X23) -> #axxisPLNat(X23) #213: #axxu205(tt(),U5) -> #axxu206(axxisLNat(U5)) #214: #axxu205(tt(),U5) -> #axxisLNat(U5) #215: #mark(u13(X38,Y38,U38)) -> #axxu13(mark(X38),Y38,U38) #216: #mark(u13(X38,Y38,U38)) -> #mark(X38) #217: #mark(u91(Y77,U77)) -> #axxu91(mark(Y77),U77) #218: #mark(u91(Y77,U77)) -> #mark(Y77) #219: #mark(u293(P55,X56,Y56)) -> #axxu293(mark(P55),X56,Y56) #220: #mark(u293(P55,X56,Y56)) -> #mark(P55) #221: #axxu331(tt(),V17,W17) -> #axxu332(axxisNaturalKind(V17),W17) #222: #axxu331(tt(),V17,W17) -> #axxisNaturalKind(V17) #223: #axxu42(tt(),Y20,U20) -> #axxu43(axxisLNatKind(U20),Y20,U20) #224: #axxu42(tt(),Y20,U20) -> #axxisLNatKind(U20) #225: #axxisNatural(s(W28)) -> #axxu191(axxisNaturalKind(W28),W28) #226: #axxisNatural(s(W28)) -> #axxisNaturalKind(W28) #227: #axxu334(tt(),Y18) -> #mark(Y18) #228: #mark(cons(P78,X79)) -> #mark(P78) #229: #mark(u73(Y76)) -> #axxu73(mark(Y76)) #230: #mark(u73(Y76)) -> #mark(Y76) #231: #mark(u255(V52,W52)) -> #axxu255(mark(V52),W52) #232: #mark(u255(V52,W52)) -> #mark(V52) #233: #axxu81(tt(),V23) -> #axxu82(axxisPLNatKind(V23),V23) #234: #axxu81(tt(),V23) -> #axxisPLNatKind(V23) #235: #mark(u204(U44,V44,W44)) -> #axxu204(mark(U44),V44,W44) #236: #mark(u204(U44,V44,W44)) -> #mark(U44) #237: #axxu294(tt(),V11,W11) -> #axxhead(axxafterNth(mark(V11),mark(W11))) #238: #axxu294(tt(),V11,W11) -> #axxafterNth(mark(V11),mark(W11)) #239: #axxu294(tt(),V11,W11) -> #mark(V11) #240: #axxu294(tt(),V11,W11) -> #mark(W11) #241: #axxu204(tt(),X5,Y5) -> #axxu205(axxisNatural(X5),Y5) #242: #axxu204(tt(),X5,Y5) -> #axxisNatural(X5) #243: #mark(u44(P70,X71,Y71)) -> #axxu44(mark(P70),X71,Y71) #244: #mark(u44(P70,X71,Y71)) -> #mark(P70) #245: #mark(u245(X50,Y50)) -> #axxu245(mark(X50),Y50) #246: #mark(u245(X50,Y50)) -> #mark(X50) #247: #axxu253(tt(),X9,Y9) -> #axxu254(axxisLNatKind(Y9),X9,Y9) #248: #axxu253(tt(),X9,Y9) -> #axxisLNatKind(Y9) #249: #axxu192(tt(),P3) -> #axxu193(axxisNatural(P3)) #250: #axxu192(tt(),P3) -> #axxisNatural(P3) #251: #axxisLNatKind(take(Y28,U28)) -> #axxu171(axxisNaturalKind(Y28),U28) #252: #axxisLNatKind(take(Y28,U28)) -> #axxisNaturalKind(Y28) #253: #mark(u122(P38)) -> #axxu122(mark(P38)) #254: #mark(u122(P38)) -> #mark(P38) #255: #axxisLNatKind(tail(X28)) -> #axxu161(axxisLNatKind(X28)) #256: #axxisLNatKind(tail(X28)) -> #axxisLNatKind(X28) #257: #mark(u191(X42,Y42)) -> #axxu191(mark(X42),Y42) #258: #mark(u191(X42,Y42)) -> #mark(X42) #259: #axxisLNatKind(fst(V27)) -> #axxu131(axxisPLNatKind(V27)) #260: #axxisLNatKind(fst(V27)) -> #axxisPLNatKind(V27) #261: #mark(u171(W40,P40)) -> #axxu171(mark(W40),P40) #262: #mark(u171(W40,P40)) -> #mark(W40) #263: #axxu41(tt(),P19,X20) -> #axxu42(axxisNaturalKind(P19),P19,X20) #264: #axxu41(tt(),P19,X20) -> #axxisNaturalKind(P19) #265: #axxu11(tt(),V1,W1) -> #axxu12(axxisNaturalKind(V1),V1,W1) #266: #axxu11(tt(),V1,W1) -> #axxisNaturalKind(V1) #267: #mark(u256(P52)) -> #axxu256(mark(P52)) #268: #mark(u256(P52)) -> #mark(P52) #269: #mark(u103(V34,W34,P34)) -> #axxu103(mark(V34),W34,P34) #270: #mark(u103(V34,W34,P34)) -> #mark(V34) #271: #mark(u52(U72,V72,W72)) -> #axxu52(mark(U72),V72,W72) #272: #mark(u52(U72,V72,W72)) -> #mark(U72) #273: #axxisNaturalKind(head(Y29)) -> #axxu211(axxisLNatKind(Y29)) #274: #axxisNaturalKind(head(Y29)) -> #axxisLNatKind(Y29) #275: #mark(u304(V58,W58)) -> #axxu304(mark(V58),W58) #276: #mark(u304(V58,W58)) -> #mark(V58) #277: #axxu12(tt(),X2,Y2) -> #axxu13(axxisLNat(Y2),X2,Y2) #278: #axxu12(tt(),X2,Y2) -> #axxisLNat(Y2) #279: #axxu45(tt(),Y21) -> #axxu46(axxisLNat(Y21)) #280: #axxu45(tt(),Y21) -> #axxisLNat(Y21) #281: #mark(u324(X63,Y63,U63,V63)) -> #axxu324(mark(X63),Y63,U63,V63) #282: #mark(u324(X63,Y63,U63,V63)) -> #mark(X63) #283: #mark(u172(X41)) -> #axxu172(mark(X41)) #284: #mark(u172(X41)) -> #mark(X41) #285: #axxisLNat(natsFrom(X26)) -> #axxu71(axxisNaturalKind(X26),X26) #286: #axxisLNat(natsFrom(X26)) -> #axxisNaturalKind(X26) #287: #axxu302(tt(),Y12) -> #axxu303(axxisLNat(Y12),Y12) #288: #axxu302(tt(),Y12) -> #axxisLNat(Y12) #289: #axxu21(tt(),V5,W5) -> #axxu22(axxisLNatKind(V5),V5,W5) #290: #axxu21(tt(),V5,W5) -> #axxisLNatKind(V5) #291: #mark(isPLNatKind(X75)) -> #axxisPLNatKind(X75) #292: #axxu322(tt(),Y14,U14,V14) -> #axxu323(axxisNatural(U14),Y14,U14,V14) #293: #axxu322(tt(),Y14,U14,V14) -> #axxisNatural(U14) #294: #mark(u111(V37,W37)) -> #axxu111(mark(V37),W37) #295: #mark(u111(V37,W37)) -> #mark(V37) #296: #mark(u203(P43,X44,Y44)) -> #axxu203(mark(P43),X44,Y44) #297: #mark(u203(P43,X44,Y44)) -> #mark(P43) #298: #axxisLNat(snd(Y26)) -> #axxu81(axxisPLNatKind(Y26),Y26) #299: #axxisLNat(snd(Y26)) -> #axxisPLNatKind(Y26) #300: #axxu105(tt(),U1) -> #axxu106(axxisLNat(U1)) #301: #axxu105(tt(),U1) -> #axxisLNat(U1) #302: #axxu244(tt(),P7,X8) -> #axxu245(axxisLNat(P7),X8) #303: #axxu244(tt(),P7,X8) -> #axxisLNat(P7) #304: #axxu303(tt(),U12) -> #axxu304(axxisLNatKind(U12),U12) #305: #axxu303(tt(),U12) -> #axxisLNatKind(U12) #306: #axxtail(cons(W32,P32)) -> #axxu331(axxisNatural(W32),W32,P32) #307: #axxtail(cons(W32,P32)) -> #axxisNatural(W32) #308: #axxu202(tt(),U4,V4) -> #axxu203(axxisLNatKind(V4),U4,V4) #309: #axxu202(tt(),U4,V4) -> #axxisLNatKind(V4) #310: #mark(u302(P57,X58)) -> #axxu302(mark(P57),X58) #311: #mark(u302(P57,X58)) -> #mark(P57) #312: #mark(u291(P54,X55,Y55)) -> #axxu291(mark(P54),X55,Y55) #313: #mark(u291(P54,X55,Y55)) -> #mark(P54) #314: #axxu182(tt(),V3) -> #axxu183(axxisLNat(V3)) #315: #axxu182(tt(),V3) -> #axxisLNat(V3) #316: #axxisLNatKind(natsFrom(W27)) -> #axxu141(axxisNaturalKind(W27)) #317: #axxisLNatKind(natsFrom(W27)) -> #axxisNaturalKind(W27) #318: #mark(snd(W39)) -> #axxsnd(mark(W39)) #319: #mark(snd(W39)) -> #mark(W39) #320: #mark(u45(U71,V71)) -> #axxu45(mark(U71),V71) #321: #mark(u45(U71,V71)) -> #mark(U71) #322: #mark(u334(P66,X67)) -> #axxu334(mark(P66),X67) #323: #mark(u334(P66,X67)) -> #mark(P66) #324: #mark(take(Y78,U78)) -> #axxtake(mark(Y78),mark(U78)) #325: #mark(take(Y78,U78)) -> #mark(Y78) #326: #mark(take(Y78,U78)) -> #mark(U78) #327: #mark(u141(Y40)) -> #axxu141(mark(Y40)) #328: #mark(u141(Y40)) -> #mark(Y40) #329: #mark(u202(U43,V43,W43)) -> #axxu202(mark(U43),V43,W43) #330: #mark(u202(U43,V43,W43)) -> #mark(U43) #331: #axxu341(tt(),V18,W18) -> #axxu342(axxisNaturalKind(V18),V18,W18) #332: #axxu341(tt(),V18,W18) -> #axxisNaturalKind(V18) #333: #axxu344(tt(),V19,W19) -> #axxfst(axxsplitAt(mark(V19),mark(W19))) #334: #axxu344(tt(),V19,W19) -> #axxsplitAt(mark(V19),mark(W19)) #335: #axxu344(tt(),V19,W19) -> #mark(V19) #336: #axxu344(tt(),V19,W19) -> #mark(W19) #337: #mark(u281(X54,Y54)) -> #axxu281(mark(X54),Y54) #338: #mark(u281(X54,Y54)) -> #mark(X54) #339: #mark(u231(V47,W47)) -> #axxu231(mark(V47),W47) #340: #mark(u231(V47,W47)) -> #mark(V47) #341: #mark(isNatural(X36)) -> #axxisNatural(X36) #342: #mark(u342(W67, ... 4 w: max(x1) USABLE RULES: { 1..407 } Removed DPs: #325 #326 #331 #377 #381 #430 #457 #463 Number of SCCs: 1, DPs: 227 SCC { #3 #9 #10 #12 #14 #15 #17..19 #21 #24 #25 #27 #35 #37 #39 #40 #42 #44 #45 #47 #52 #56..61 #65 #67..70 #72 #79 #80 #83 #85 #86 #88 #90..94 #96 #99 #102 #103 #108 #113..115 #117 #119 #120 #122 #123 #130 #133 #134 #136 #140 #141 #147..150 #153 #156 #157 #161 #163 #164 #166 #167 #169..175 #177 #186 #188..191 #194 #198 #205 #207 #208 #210 #215 #216 #218..221 #227 #228 #230 #232 #236..240 #244 #246 #254 #258 #262 #265 #268 #270 #272 #275..277 #281 #282 #284 #287 #289 #292 #295 #297 #304 #306 #310..313 #318 #319 #321..323 #328 #330 #333..338 #340 #342 #343 #347 #350 #354..357 #359 #361 #362 #365 #369 #371 #373..376 #379 #380 #384 #389 #391 #393 #395 #397 #399..402 #405..407 #410 #412 #413 #415 #418..420 #422 #423 #431 #432 #440..444 #446..448 #452 #455 #456 #462 #464 #466..473 #476..478 #482..484 #487 #488 #491 #496..498 } POLO(Sum)... POLO(max)... succeeded. #axxu172 w: 0 u81 w: max(x1 + 1, x2 + 37812) #axxu256 w: 0 #axxu51 w: 0 u327 w: max(x1, x2 + 131419) axxu104 w: max(x1 + 155290, x2 + 1263, x3 + 155289) #axxu246 w: 0 u83 w: x1 + 204 #axxu122 w: 0 #axxu311 w: max(x1 + 140989, x2 + 140989) axxu302 w: max(x1 + 8, x2 + 9) u172 w: x1 + 181721 axxu245 w: max(x1 + 7, x2 + 6) u244 w: max(x1 + 10, x2 + 8, x3 + 9) u292 w: max(x1 + 188817, x2 + 188821, x3 + 188057) #axxu32 w: max(x1 + 21561, x2 + 21561, x3 + 21564) u13 w: max(x1 + 170982, x2 + 170981, x3 + 170982) axxu13 w: max(x1 + 170982, x2 + 170981, x3 + 170982) u62 w: max(x1, x2 + 10959) #axxu327 w: max(x1 + 9556, x2 + 131542) axxu232 w: x1 + 7571 #axxu244 w: 0 u341 w: max(x1 + 181711, x2 + 181719, x3 + 181720) #axxu141 w: 0 axxu211 w: x1 + 6740 #axxu254 w: 0 axxu62 w: max(x1, x2 + 10959) u253 w: max(x1, x2 + 64744, x3 + 64745) #axxu103 w: 0 u344 w: max(x1 + 162318, x2 + 162317, x3 + 162314) s w: x1 u241 w: max(x1 + 15, x2 + 16, x3 + 14) axxu253 w: max(x1, x2 + 64744, x3 + 64745) u322 w: max(x1 + 131402, x2 + 131412, x3 + 160129, x4 + 131418) axxisLNat w: x1 axxu324 w: max(x1 + 131420, x2 + 131412, x3 + 131419, x4 + 131418) u304 w: max(x1 + 3, x2 + 3) #axxu12 w: max(x1 + 180557, x2 + 180554, x3 + 180556) axxu121 w: max(x1, x2) u91 w: max(x1 + 4689, x2 + 33875) #axxu111 w: 0 axxu311 w: max(x1 + 131415, x2 + 131418) axxisPLNatKind w: x1 + 1 #axxu14 w: max(x2 + 140989, x3 + 140989) u246 w: x1 + 6 #axxu192 w: 0 axxu327 w: max(x1, x2 + 131419) u261 w: max(x1, x2 + 97875) axxu63 w: x1 + 394 u53 w: max(x1, x2 + 9972, x3) isPLNatKind w: x1 + 1 u111 w: max(x1 + 173108, x2 + 173109) #axxu211 w: 0 #axxu82 w: 0 axxu46 w: x1 + 2344 u23 w: max(x1 + 7, x2 + 6, x3 + 4) u104 w: max(x1 + 155290, x2 + 1263, x3 + 155289) #axxu92 w: 0 axxu131 w: x1 + 7 axxu294 w: max(x1 + 185119, x2 + 185117, x3 + 185118) u191 w: max(x1 + 1, x2 + 10) axxu252 w: max(x1 + 127821, x2 + 127822, x3 + 127820) isPLNat w: x1 axxsnd w: x1 + 39561 u102 w: max(x1, x2 + 155288, x3 + 156708) axxu191 w: max(x1 + 1, x2 + 10) #axxu271 w: 0 axxu11 w: max(x1 + 173101, x2 + 170989, x3 + 170985) u121 w: max(x1, x2) #axxu206 w: 0 #axxu312 w: max(x2 + 140979) axxu32 w: max(x1 + 11989, x2 + 11991, x3 + 11994) axxu172 w: x1 + 181721 #axxu102 w: 0 #axxu193 w: 0 #axxu101 w: 0 #axxu341 w: 0 #axxu181 w: 0 u181 w: max(x1 + 3985, x2 + 6813) #axxisLNat w: 0 u243 w: max(x1 + 12, x2 + 11, x3 + 10) axxu55 w: max(x1, x2) take w: max(x1 + 192353, x2 + 181721) u105 w: max(x1 + 1, x2 + 146151) #axxu93 w: 0 u293 w: max(x1, x2 + 188110, x3 + 185119) #axxu204 w: 0 u122 w: x1 axxu255 w: max(x1, x2) u302 w: max(x1 + 8, x2 + 9) #axxu322 w: max(x2 + 140975, x3 + 140990, x4 + 140989) axxsplitAt w: max(x1 + 131412, x2 + 131418) u103 w: max(x1 + 155289, x2 + 155288, x3 + 155290) #axxu221 w: 0 #axxu324 w: max(x1 + 140979, x2 + 140975, x3 + 140977, x4 + 140989) #axxu55 w: 0 #axxu302 w: max(x1 + 9582, x2 + 9579) u205 w: max(x1 + 1, x2 + 9172) axxu33 w: max(x1 + 11990, x2 + 11987, x3 + 11989) axxu242 w: max(x1 + 16, x2 + 11, x3 + 12) axxu304 w: max(x1 + 3, x2 + 3) u54 w: max(x1, x2 + 5917, x3) axxu312 w: max(x1 + 131418, x2 + 131417) pair w: max(x1 + 17, x2 + 115484) axxu91 w: max(x1 + 4689, x2 + 33875) fst w: x1 + 25093 axxu56 w: x1 #axxu151 w: 0 u24 w: max(x1 + 1, x2 + 3) u131 w: x1 + 7 u252 w: max(x1 + 127821, x2 + 127822, x3 + 127820) #axxu303 w: max(x2 + 9577) u282 w: max(x1, x2 + 105357) natsFrom w: x1 + 105357 u303 w: max(x1 + 9, x2 + 4) u182 w: max(x1 + 4563, x2 + 4564) #axxu326 w: max(x1 + 20496, x2 + 140975, x3 + 131543, x4 + 140989) axxu261 w: max(x1, x2 + 97875) #axxu245 w: 0 axxu103 w: max(x1 + 155289, x2 + 155288, x3 + 155290) u294 w: max(x1 + 185119, x2 + 185117, x3 + 185118) u251 w: max(x1 + 127825, x2 + 127826, x3 + 131417) #axxu242 w: 0 u332 w: max(x1 + 4, x2 + 28075) u33 w: max(x1 + 11990, x2 + 11987, x3 + 11989) axxu14 w: max(x1 + 170981, x2 + 170979, x3 + 170980) #axxu23 w: max(x1 + 9577, x2 + 9579, x3 + 507) #axxu183 w: 0 u323 w: max(x1 + 160119, x2 + 131412, x3 + 147647, x4 + 131418) #axxu334 w: max(x1 + 9575, x2 + 9575) #axxu54 w: 0 splitAt w: max(x1 + 131412, x2 + 131418) u192 w: max(x1 + 1, x2 + 10) #axxu301 w: max(x2 + 9583, x3 + 9585) #axxu332 w: max(x1 + 9578, x2 + 9577) isNaturalKind w: x1 + 4 #axxu11 w: max(x2 + 180561, x3 + 180557) u52 w: max(x1 + 87468, x2 + 17135, x3) axxu201 w: max(x1 + 127818, x2 + 184933, x3 + 187596) #axxu333 w: max(x2 + 9576) #axxu325 w: max(x2 + 140975, x3 + 140977, x4 + 140989) #axxu232 w: 0 u291 w: max(x1 + 188823, x2 + 188822, x3 + 188820) axxu102 w: max(x1, x2 + 155288, x3 + 156708) u61 w: max(x1 + 20181, x2 + 20180) #axxu43 w: 0 u92 w: max(x1 + 32896, x2 + 6041) axxu83 w: x1 + 204 axxu31 w: max(x1 + 11994, x2 + 11993, x3 + 12000) #axxu83 w: 0 axxu72 w: max(x1 + 105352, x2 + 105353) #axxu33 w: max(x2 + 21560, x3 + 21562) u221 w: x1 axxu203 w: max(x1 + 15001, x2 + 15000, x3 + 14999) axxu246 w: x1 + 6 #axxisNaturalKind w: 0 u56 w: x1 axxu342 w: max(x1 + 181715, x2 + 181710, x3 + 181712) _ w: 0 axxu183 w: x1 + 4564 axxu281 w: max(x1 + 2812, x2 + 105357) axxu193 w: x1 u324 w: max(x1 + 131420, x2 + 131412, x3 + 131419, x4 + 131418) axxu192 w: max(x1 + 1, x2 + 10) #axxu344 w: max(x2 + 171886, x3 + 140989) u151 w: x1 + 6069 axxu22 w: max(x1 + 8, x2 + 10, x3 + 7) #axxu292 w: max(x2 + 198392, x3 + 194693) u202 w: max(x1 + 127814, x2 + 15000, x3 + 15001) axxu44 w: max(x1 + 9713, x2 + 50867, x3 + 169169) isNatural w: x1 + 10 #axxu294 w: max(x2 + 194686, x3 + 194679) axxu333 w: max(x1, x2 + 21716) #axxu45 w: 0 u106 w: x1 + 2948 axxu24 w: max(x1 + 1, x2 + 3) #axxu121 w: 0 axxu341 w: max(x1 + 181711, x2 + 181719, x3 + 181720) axxu323 w: max(x1 + 160119, x2 + 131412, x3 + 147647, x4 + 131418) axxu344 w: max(x1 + 162318, x2 + 162317, x3 + 162314) axxu291 w: max(x1 + 188823, x2 + 188822, x3 + 188820) #axxsplitAt w: max(x1 + 140975, x2 + 140989) axxnatsFrom w: x1 + 105357 u41 w: max(x1 + 173107, x2 + 169168, x3 + 169170) #axxu343 w: max(x1 + 171893, x2 + 171887, x3 + 171885) axxisNatural w: x1 + 10 u211 w: x1 + 6740 axxu151 w: x1 + 6069 u45 w: max(x1 + 42996, x2 + 13388) #axxu321 w: max(x2 + 140975, x3 + 140991, x4 + 140989) u63 w: x1 + 394 #axxu112 w: 0 axxu181 w: max(x1 + 3985, x2 + 6813) axxu23 w: max(x1 + 7, x2 + 6, x3 + 4) #axxu91 w: 0 #axxu205 w: 0 #axxu56 w: 0 u342 w: max(x1 + 181715, x2 + 181710, x3 + 181712) #axxu201 w: 0 axxu334 w: max(x1 + 757, x2 + 20002) tail w: x1 + 35138 u51 w: max(x1, x2 + 87472, x3) #axxu342 w: max(x1 + 191288, x2 + 186455, x3 + 191285) #axxafterNth w: max(x1 + 182686, x2 + 180562) #axxu44 w: 0 #mark w: x1 + 9574 #axxtail w: x1 + 9583 u271 w: max(x1, x2 + 131419) 0 w: 14 axxu82 w: max(x1 + 30433, x2 + 16951) axxu244 w: max(x1 + 10, x2 + 8, x3 + 9) axxu243 w: max(x1 + 12, x2 + 11, x3 + 10) #axxnatsFrom w: x1 + 114930 axxu141 w: x1 + 3850 axxisPLNat w: x1 #axxu72 w: 0 axxu81 w: max(x1 + 1, x2 + 37812) #axxisPLNat w: 0 u333 w: max(x1, x2 + 21716) #axxu106 w: 0 #axxu251 w: 0 axxu182 w: max(x1 + 4563, x2 + 4564) u11 w: max(x1 + 173101, x2 + 170989, x3 + 170985) sel w: max(x1 + 189690, x2 + 188821) axxu204 w: max(x1 + 14998, x2 + 14997, x3 + 14999) u312 w: max(x1 + 131418, x2 + 131417) #axxisLNatKind w: 0 axxu301 w: max(x1 + 12, x2 + 8509, x3 + 13) u32 w: max(x1 + 11989, x2 + 11991, x3 + 11994) axxu292 w: max(x1 + 188817, x2 + 188821, x3 + 188057) u73 w: x1 + 105343 #axxu272 w: 0 afterNth w: max(x1 + 173113, x2 + 173111) #axxisPLNatKind w: 0 #axxu62 w: 0 #axxu161 w: 0 axxu293 w: max(x1, x2 + 188110, x3 + 185119) u46 w: x1 + 2344 #axxu261 w: 0 axxu73 w: x1 + 105343 u14 w: max(x1 + 170981, x2 + 170979, x3 + 170980) nil w: 131401 #axxsnd w: x1 + 9567 axxu343 w: max(x1 + 162319, x2 + 163789, x3 + 162318) u325 w: max(x1 + 131417, x2 + 131412, x3 + 131419, x4 + 131418) isLNat w: x1 #axxu21 w: max(x2 + 9583, x3 + 9586) axxu41 w: max(x1 + 173107, x2 + 169168, x3 + 169170) #axxu105 w: 0 #axxu202 w: 0 axxafterNth w: max(x1 + 173113, x2 + 173111) #axxu262 w: 0 u12 w: max(x1 + 170985, x2 + 170983, x3 + 170982) mark w: x1 axxu332 w: max(x1 + 4, x2 + 28075) axxu205 w: max(x1 + 1, x2 + 9172) u203 w: max(x1 + 15001, x2 + 15000, x3 + 14999) #axxu22 w: max(x2 + 9583, x3 + 9578) u101 w: max(x1 + 192349, x2 + 188093, x3 + 156708) #axxu73 w: 0 #axxu81 w: 0 axxu331 w: max(x1, x2 + 27597, x3 + 28407) u301 w: max(x1 + 12, x2 + 8509, x3 + 13) axxu71 w: max(x1 + 105353, x2 + 105356) #axxu252 w: 0 axxsel w: max(x1 + 189690, x2 + 188821) u72 w: max(x1 + 105352, x2 + 105353) u21 w: max(x1 + 11, x2 + 10, x3 + 836) u201 w: max(x1 + 127818, x2 + 184933, x3 + 187596) u262 w: x1 + 2202 axxu52 w: max(x1 + 87468, x2 + 17135, x3) u331 w: max(x1, x2 + 27597, x3 + 28407) axxu122 w: x1 u93 w: x1 + 1274 u206 w: x1 + 1 #axxu291 w: max(x1 + 198397, x2 + 198395, x3 + 198393) #axxu253 w: 0 isLNatKind w: x1 u272 w: x1 u255 w: max(x1, x2) #axxu52 w: 0 axxu326 w: max(x1 + 13530, x2 + 131412, x3 + 131419, x4 + 131418) axxfst w: x1 + 25093 axxu61 w: max(x1 + 20181, x2 + 20180) u43 w: max(x1 + 169170, x2 + 169168, x3 + 169169) axxu111 w: max(x1 + 173108, x2 + 173109) axxu321 w: max(x1 + 131402, x2 + 131412, x3 + 227861, x4 + 131418) u183 w: x1 + 4564 axxu106 w: x1 + 2948 axxu171 w: max(x1 + 181720, x2 + 181721) axxu282 w: max(x1, x2 + 105357) #axxu331 w: max(x1 + 9574, x2 + 9582, x3 + 9582) u82 w: max(x1 + 30433, x2 + 16951) #_ w: 0 u161 w: x1 + 34013 #axxu31 w: max(x1 + 21566, x2 + 21566, x3 + 21566) u204 w: max(x1 + 14998, x2 + 14997, x3 + 14999) axxisNaturalKind w: x1 + 4 #axxu46 w: 0 #axxsel w: max(x1 + 198887, x2 + 198394) u321 w: max(x1 + 131402, x2 + 131412, x3 + 227861, x4 + 131418) axxu241 w: max(x1 + 15, x2 + 16, x3 + 14) #axxu42 w: 0 axxu325 w: max(x1 + 131417, x2 + 131412, x3 + 131419, x4 + 131418) axxu51 w: max(x1, x2 + 87472, x3) u171 w: max(x1 + 181720, x2 + 181721) u334 w: max(x1 + 757, x2 + 20002) #axxu323 w: max(x2 + 140975, x3 + 140984, x4 + 140989) axxu221 w: x1 head w: x1 + 12004 u34 w: max(x1 + 1, x2 + 11868) #axxu13 w: max(x2 + 180553, x3 + 180551) axxu92 w: max(x1 + 32896, x2 + 6041) u245 w: max(x1 + 7, x2 + 6) cons w: max(x1 + 96443, x2) #axxu104 w: 0 u311 w: max(x1 + 131415, x2 + 131418) axxu303 w: max(x1 + 9, x2 + 4) axxu45 w: max(x1 + 42996, x2 + 13388) snd w: x1 + 39561 #axxu41 w: 0 u22 w: max(x1 + 8, x2 + 10, x3 + 7) u281 w: max(x1 + 2812, x2 + 105357) axxu54 w: max(x1, x2 + 5917, x3) axxu105 w: max(x1 + 1, x2 + 146151) axxu206 w: x1 + 1 axxu12 w: max(x1 + 170985, x2 + 170983, x3 + 170982) axxu254 w: max(x1 + 64744, x2 + 5903, x3 + 5903) axxtail w: x1 + 35138 u112 w: x1 + 173109 u42 w: max(x1, x2 + 169168, x3 + 169170) tt w: 0 u55 w: max(x1, x2) #axxu243 w: 0 #axxu191 w: 0 #axxu231 w: 0 #axxu131 w: 0 axxu42 w: max(x1, x2 + 169168, x3 + 169170) #axxu304 w: max(x2 + 9576) axxu251 w: max(x1 + 127825, x2 + 127826, x3 + 131417) u343 w: max(x1 + 162319, x2 + 163789, x3 + 162318) u232 w: x1 + 7571 axxu271 w: max(x1, x2 + 131419) #axxu281 w: max(x1 + 9578, x2 + 9579) #axxu241 w: 0 axxisLNatKind w: x1 axxu161 w: x1 + 34013 axxu262 w: x1 + 2202 axxu202 w: max(x1 + 127814, x2 + 15000, x3 + 15001) #axxu53 w: 0 u242 w: max(x1 + 16, x2 + 11, x3 + 12) u71 w: max(x1 + 105353, x2 + 105356) #axxu255 w: 0 axxu231 w: max(x1 + 188822, x2 + 188823) axxu93 w: x1 + 1274 axxtake w: max(x1 + 192353, x2 + 181721) #axxu61 w: 0 axxu53 w: max(x1, x2 + 9972, x3) #axxfst w: x1 + 9570 #axxu171 w: 0 axxu101 w: max(x1 + 192349, x2 + 188093, x3 + 156708) u231 w: max(x1 + 188822, x2 + 188823) #axxu71 w: 0 axxu256 w: x1 #axxisNatural w: 0 #axxu63 w: 0 #axxu34 w: max(x2 + 12169) u193 w: x1 #axxu24 w: max(x2 + 9576) axxu272 w: x1 axxu112 w: x1 + 173109 u31 w: max(x1 + 11994, x2 + 11993, x3 + 12000) axxu34 w: max(x1 + 1, x2 + 11868) u141 w: x1 + 3850 u44 w: max(x1 + 9713, x2 + 50867, x3 + 169169) axxu322 w: max(x1 + 131402, x2 + 131412, x3 + 160129, x4 + 131418) axxu21 w: max(x1 + 11, x2 + 10, x3 + 836) #axxu182 w: 0 #axxu203 w: 0 #axxtake w: 0 #axxu293 w: max(x2 + 194694, x3 + 194693) #axxu282 w: max(x1 + 9573, x2 + 9578) axxu43 w: max(x1 + 169170, x2 + 169168, x3 + 169169) u256 w: x1 #axxhead w: x1 + 21567 u326 w: max(x1 + 13530, x2 + 131412, x3 + 131419, x4 + 131418) axxhead w: x1 + 12004 u254 w: max(x1 + 64744, x2 + 5903, x3 + 5903) USABLE RULES: { 1..407 } Removed DPs: #3 #12 #14 #15 #17..19 #24 #25 #27 #37 #39 #40 #42 #44 #45 #47 #56..60 #67..69 #79 #85 #86 #90..93 #99 #102 #103 #113..115 #117 #120 #122 #123 #130 #134 #136 #140 #147..150 #153 #156 #157 #163 #164 #166 #167 #169 #170 #172..175 #177 #186 #188..190 #194 #198 #205 #207 #208 #210 #215 #216 #218 #227 #228 #230 #236..240 #244 #246 #258 #262 #270 #272 #275..277 #281 #282 #284 #287 #295 #297 #304 #306 #311 #313 #318 #319 #321..323 #328 #330 #333 #335..338 #340 #342 #343 #347 #350 #355 #357 #359 #361 #369 #371 #373..376 #379 #384 #389 #391 #397 #399..402 #405..407 #410 #412 #413 #418 #420 #422 #423 #431 #432 #440..444 #447 #448 #452 #455 #456 #462 #464 #466..469 #471..473 #476..478 #483 #484 #487 #488 #491 #496 #498 Number of SCCs: 2, DPs: 31 SCC { #52 #70 #72 #80 #88 #171 #292 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... succeeded. #axxu172 s: [] p: 0 w: 1 u81 s: [] p: 15 w: max(x2 + 12) #axxu256 s: [] p: 0 w: 1 #axxu51 s: [] p: 0 w: 0 u327 s: [2] p: 12 w: max(x1, x2 + 21) axxu104 s: [] p: 13 w: max(x1 + 16679) #axxu246 s: [] p: 0 w: 1 u83 s: 1 #axxu122 s: [] p: 0 w: 1 #axxu311 s: [] p: 0 w: max(x1 + 1) axxu302 s: [2] p: 19 w: max(x2 + 7) u172 s: [] p: 11 w: 6 axxu245 s: [] p: 10 w: max(x2 + 3) u244 s: [] p: 0 w: max(x3 + 8) u292 s: [3] p: 12 w: max(x1 + 30169, x2 + 30167, x3 + 30170) #axxu32 s: [2] p: 0 w: x2 u13 s: [1] p: 22 w: max(x1 + 29887, x2 + 22116, x3 + 29886) axxu13 s: [1] p: 22 w: max(x1 + 29887, x2 + 22116, x3 + 29886) u62 s: [] p: 1 w: max(x2 + 2) #axxu327 s: [] p: 0 w: x2 axxu232 s: [] p: 10 w: 2 #axxu244 s: [2] p: 0 w: max(x2) u341 s: [] p: 25 w: max(x2 + 27764, x3 + 31990) #axxu141 s: [] p: 0 w: 1 axxu211 s: [] p: 17 w: 6 #axxu254 s: [1,2] p: 0 w: max(x1 + 1, x2, x3 + 1) axxu62 s: [] p: 1 w: max(x2 + 2) u253 s: [3] p: 12 w: max(x1, x3 + 1949) #axxu103 s: [1,3] p: 0 w: max(x1, x2, x3 + 1) u344 s: [] p: 22 w: max(x2 + 20390, x3 + 16255) s s: [1] p: 21 w: x1 u241 s: [1] p: 2 w: max(x1 + 14985, x3 + 14985) axxu253 s: [3] p: 12 w: max(x1, x3 + 1949) u322 s: [2,3,4] p: 19 w: max(x2 + 16271, x3 + 16272, x4 + 16255) axxisLNat s: [] p: 15 w: x1 + 4 axxu324 s: [] p: 16 w: max(x2 + 16271, x3 + 24, x4 + 16255) u304 s: [] p: 18 w: max(x2 + 1) #axxu12 s: [2] p: 0 w: max(x2) axxu121 s: [1] p: 13 w: max(x1 + 6) u91 s: [] p: 8 w: max(x1 + 13517, x2 + 13552) #axxu111 s: [] p: 0 w: 0 axxu311 s: [] p: 21 w: max(x2 + 15983) axxisPLNatKind s: [] p: 23 w: 18 #axxu14 s: [3,1,2] p: 0 w: x1 + x2 + x3 + 1 u246 s: [] p: 10 w: 1 #axxu192 s: [2,1] p: 0 w: max(x1 + 1, x2) axxu327 s: [2] p: 12 w: max(x1, x2 + 21) u261 s: [] p: 23 w: 0 axxu63 s: [] p: 1 w: 1 u53 s: [] p: 18 w: max(x2 + 1) isPLNatKind s: [] p: 23 w: 18 u111 s: [] p: 12 w: max(x1 + 5) #axxu211 s: [] p: 0 w: 1 #axxu82 s: [2] p: 0 w: max(x2) axxu46 s: [] p: 1 w: 17 u23 s: [3,1,2] p: 18 w: max(x1 + 5310, x2, x3 + 8056) u104 s: [] p: 13 w: max(x1 + 16679) #axxu92 s: [] p: 0 w: max(x1) axxu131 s: [] p: 17 w: 0 axxu294 s: [3] p: 18 w: max(x2 + 30162, x3 + 30165) u191 s: [] p: 12 w: max(x1 + 56) axxu252 s: [] p: 13 w: max(x1 + 34, x3 + 16253) isPLNat s: [] p: 15 w: x1 axxsnd s: [1] p: 22 w: x1 + 13 u102 s: [] p: 15 w: max(x1 + 32958) axxu191 s: [] p: 12 w: max(x1 + 56) #axxu271 s: [1] p: 0 w: max(x1 + 1) axxu11 s: [] p: 23 w: max(x1 + 29894, x2 + 29893, x3 + 30031) u121 s: [1] p: 13 w: max(x1 + 6) #axxu206 s: [] p: 0 w: 1 #axxu312 s: [1,2] p: 0 w: x1 + x2 + 1 axxu32 s: [] p: 2 w: max(x2 + 52, x3 + 50) axxu172 s: [] p: 11 w: 6 #axxu102 s: [] p: 0 w: max(x3) #axxu193 s: [] p: 0 w: 0 #axxu101 s: [3,1,2] p: 0 w: max(x1, x2 + 1, x3 + 1) #axxu341 s: [1,3] p: 0 w: max(x1 + 1, x2 + 1, x3 + 1) #axxu181 s: [1,2] p: 0 w: max(x1, x2) u181 s: [] p: 18 w: 0 #axxisLNat s: [] p: 0 w: 0 u243 s: [] p: 1 w: max(x1 + 10043, x3 + 28) axxu55 s: [] p: 18 w: 0 take s: [] p: 25 w: x1 + x2 + 35471 u105 s: [] p: 14 w: max(x1 + 3) #axxu93 s: [] p: 0 w: 0 u293 s: [3] p: 12 w: max(x1 + 30164, x2 + 30163, x3 + 30166) #axxu204 s: [3] p: 0 w: max(x3) u122 s: [] p: 14 w: 3 axxu255 s: [1] p: 10 w: max(x1 + 2) u302 s: [2] p: 19 w: max(x2 + 7) #axxu322 s: [2] p: 12 w: max(x1 + 133, x2 + 264) axxsplitAt s: [] p: 21 w: max(x1 + 16271, x2 + 16255) u103 s: [] p: 13 w: max(x1 + 32924) #axxu221 s: [] p: 0 w: 0 #axxu324 s: [2] p: 12 w: max(x1 + 226, x2 + 264) #axxu55 s: [] p: 0 w: max(x2 + 1) #axxu302 s: [1] p: 0 w: max(x1 + 1) u205 s: [] p: 18 w: 0 axxu33 s: [2] p: 1 w: max(x2 + 51, x3 + 49) axxu242 s: [3] p: 1 w: max(x3 + 10077) axxu304 s: [] p: 18 w: max(x2 + 1) u54 s: [] p: 18 w: max(x2) axxu312 s: [] p: 21 w: max(x1 + 15019, x2 + 15019) pair s: [1] p: 3 w: max(x1, x2 + 15019) axxu91 s: [] p: 8 w: max(x1 + 13517, x2 + 13552) fst s: [1] p: 19 w: x1 axxu56 s: [] p: 18 w: 0 #axxu151 s: [] p: 0 w: 0 u24 s: [2] p: 9 w: max(x2) u131 s: [] p: 17 w: 0 u252 s: [] p: 13 w: max(x1 + 34, x3 + 16253) #axxu303 s: [] p: 0 w: x2 u282 s: [] p: 22 w: max(x2 + 21) natsFrom s: [] p: 23 w: x1 + 21 u303 s: [] p: 18 w: max(x1 + 2, x2 + 4) u182 s: [] p: 17 w: 0 #axxu326 s: [2] p: 12 w: max(x1 + 51, x2 + 264) axxu261 s: [] p: 23 w: 0 #axxu245 s: [] p: 0 w: max(x1) axxu103 s: [] p: 13 w: max(x1 + 32924) u294 s: [3] p: 18 w: max(x2 + 30162, x3 + 30165) u251 s: [] p: 14 w: max(x1 + 60, x3 + 16254) #axxu242 s: [2,1,3] p: 0 w: max(x1 + 1, x2 + 1, x3) u332 s: 2 u33 s: [2] p: 1 w: max(x2 + 51, x3 + 49) axxu14 s: [] p: 21 w: max(x2 + 17697, x3 + 16270) #axxu23 s: [] p: 0 w: x3 + 1 #axxu183 s: [] p: 0 w: 0 u323 s: [] p: 18 w: max(x2 + 16271, x3 + 25, x4 + 16255) #axxu334 s: [1] p: 0 w: x1 #axxu54 s: [3,2] p: 0 w: max(x2, x3) splitAt s: [] p: 21 w: max(x1 + 16271, x2 + 16255) u192 s: [1] p: 12 w: max(x1) #axxu301 s: [2,3] p: 0 w: x2 + x3 #axxu332 s: [2] p: 0 w: max(x2) isNaturalKind s: [] p: 12 w: 26 #axxu11 s: [2,1,3] p: 0 w: x1 + x2 + x3 + 1 u52 s: [3,2] p: 18 w: max(x2 + 2, x3) axxu201 s: [] p: 18 w: max(x1 + 105) #axxu333 s: [] p: 0 w: x2 + 1 #axxu325 s: [2] p: 12 w: max(x2 + 264) #axxu232 s: [] p: 0 w: 1 u291 s: [] p: 12 w: max(x1 + 30168, x2 + 30196, x3 + 30194) axxu102 s: [] p: 15 w: max(x1 + 32958) u61 s: [] p: 1 w: max(x2 + 3) #axxu43 s: [2] p: 0 w: max(x1, x2 + 1) u92 s: [1,2] p: 7 w: max(x1, x2 + 13546) axxu83 s: 1 axxu31 s: [] p: 2 w: max(x2 + 145, x3 + 51) #axxu83 s: [] p: 0 w: 1 axxu72 s: [] p: 9 w: max(x2 + 17) #axxu33 s: [] p: 0 w: x1 + x2 + x3 u221 s: [] p: 18 w: 18 axxu203 s: [] p: 18 w: max(x1 + 43) axxu246 s: [] p: 10 w: 1 #axxisNaturalKind s: [] p: 0 w: 0 u56 s: [] p: 18 w: 0 axxu342 s: [2,3] p: 24 w: max(x1 + 31964, x2 + 26907, x3 + 31990) _ s: [2,1] p: 0 w: x1 + x2 axxu183 s: [] p: 17 w: 0 axxu281 s: [] p: 23 w: max(x2 + 21) axxu193 s: [] p: 17 w: 0 u324 s: [] p: 16 w: max(x2 + 16271, x3 + 24, x4 + 16255) axxu192 s: [1] p: 12 w: max(x1) #axxu344 s: [2] p: 0 w: x2 + 1 u151 s: [] p: 12 w: 14 axxu22 s: [2] p: 19 w: max(x2, x3 + 15019) #axxu292 s: [1] p: 0 w: x1 u202 s: [] p: 18 w: max(x1 + 79) axxu44 s: [] p: 18 w: max(x2 + 33, x3 + 88) isNatural s: [] p: 12 w: 133 #axxu294 s: [] p: 0 w: x2 + x3 + 1 axxu333 s: 2 #axxu45 s: [2] p: 0 w: max(x2) u106 s: [] p: 17 w: 1 axxu24 s: [2] p: 9 w: max(x2) #axxu121 s: [] p: 0 w: 0 axxu341 s: [] p: 25 w: max(x2 + 27764, x3 + 31990) axxu323 s: [] p: 18 w: max(x2 + 16271, x3 + 25, x4 + 16255) axxu344 s: [] p: 22 w: max(x2 + 20390, x3 + 16255) axxu291 s: [] p: 12 w: max(x1 + 30168, x2 + 30196, x3 + 30194) #axxsplitAt s: [1] p: 12 w: max(x1 + 264) axxnatsFrom s: [] p: 23 w: x1 + 21 u41 s: [1,2,3] p: 9 w: max(x1 + 24936, x2 + 24935, x3 + 24934) #axxu343 s: [2,1] p: 0 w: max(x1, x2) axxisNatural s: [] p: 12 w: 133 u211 s: [] p: 17 w: 6 axxu151 s: [] p: 12 w: 14 u45 s: [] p: 1 w: max(x2 + 84) #axxu321 s: [2] p: 12 w: max(x1 + 131, x2 + 264) u63 s: [] p: 1 w: 1 #axxu112 s: [] p: 0 w: 0 axxu181 s: [] p: 18 w: 0 axxu23 s: [3,1,2] p: 18 w: max(x1 + 5310, x2, x3 + 8056) #axxu91 s: [] p: 0 w: max(x1 + 1) #axxu205 s: [2] p: 0 w: max(x2) #axxu56 s: [] p: 0 w: 0 u342 s: [2,3] p: 24 w: max(x1 + 31964, x2 + 26907, x3 + 31990) #axxu201 s: [] p: 0 w: max(x1 + 1) axxu334 s: 2 tail s: [1] p: 10 w: x1 + 13550 u51 s: [3] p: 15 w: max(x2 + 3, x3 + 1) #axxu342 s: [] p: 0 w: x2 #axxafterNth s: [2] p: 0 w: x2 #axxu44 s: [2,1] p: 0 w: max(x1 + 1, x2, x3 + 1) #mark s: [] p: 0 w: 0 #axxtail s: [] p: 0 w: 1 u271 s: [] p: 23 w: 0 0 s: [] p: 18 w: 2 axxu82 s: [] p: 15 w: max(x2) axxu244 s: [] p: 0 w: max(x3 + 8) axxu243 s: [] p: 1 w: max(x1 + 10043, x3 + 28) #axxnatsFrom s: [] p: 0 w: 1 axxu141 s: [] p: 12 w: 17 axxisPLNat s: [] p: 15 w: x1 #axxu72 s: [] p: 0 w: 0 axxu81 s: [] p: 15 w: max(x2 + 12) #axxisPLNat s: [] p: 0 w: 0 u333 s: 2 #axxu106 s: [] p: 0 w: 0 #axxu251 s: [1,3] p: 0 w: max(x1, x2, x3 + 1) axxu182 s: [] p: 17 w: 0 u11 s: [] p: 23 w: max(x1 + 29894, x2 + 29893, x3 + 30031) sel s: [1] p: 19 w: x1 + x2 + 30302 axxu204 s: [] p: 18 w: max(x1 + 8) u312 s: [] p: 21 w: max(x1 + 15019, x2 + 15019) #axxisLNatKind s: [] p: 0 w: 0 axxu301 s: [2] p: 20 w: max(x1 + 9, x2 + 8, x3 + 23) u32 s: [] p: 2 w: max(x2 + 52, x3 + 50) axxu292 s: [3] p: 12 w: max(x1 + 30169, x2 + 30167, x3 + 30170) u73 s: [] p: 18 w: 4 #axxu272 s: [] p: 0 w: 0 afterNth s: [] p: 23 w: max(x1 + 30027, x2 + 30031) #axxisPLNatKind s: [] p: 0 w: 0 #axxu62 s: [1] p: 0 w: max(x1 + 1) #axxu161 s: [] p: 0 w: 1 axxu293 s: [3] p: 12 w: max(x1 + 30164, x2 + 30163, x3 + 30166) u46 s: [] p: 1 w: 17 #axxu261 s: [] p: 0 w: max(x2) axxu73 s: [] p: 18 w: 4 u14 s: [] p: 21 w: max(x2 + 17697, x3 + 16270) nil s: [] p: 16 w: 0 #axxsnd s: [] p: 0 w: 1 axxu343 s: [1,2] p: 23 w: max(x1 + 25969, x2 + 23780, x3 + 31965) u325 s: [] p: 15 w: max(x1 + 10, x2 + 16271, x3 + 23, x4 + 16255) isLNat s: [] p: 15 w: x1 + 4 #axxu21 s: [2] p: 0 w: x1 + x2 + x3 + 1 axxu41 s: [1,2,3] p: 9 w: max(x1 + 24936, x2 + 24935, x3 + 24934) #axxu105 s: [] p: 0 w: max(x1 + 1) #axxu202 s: [3,2] p: 0 w: max(x2, x3 + 1) axxafterNth s: [] p: 23 w: max(x1 + 30027, x2 + 30031) #axxu262 s: [] p: 0 w: 0 u12 s: [] p: 23 w: max(x2 + 29886, x3 + 29892) mark s: 1 axxu332 s: 2 axxu205 s: [] p: 18 w: 0 u203 s: [] p: 18 w: max(x1 + 43) #axxu22 s: [] p: 0 w: max(x2) u101 s: [] p: 15 w: max(x1 + 35444) #axxu73 s: [] p: 0 w: 0 #axxu81 s: [1] p: 0 w: max(x1 + 1) axxu331 s: [2,1] p: 0 w: max(x1 + 13417, x2 + 10, x3 + 13417) u301 s: [2] p: 20 w: max(x1 + 9, x2 + 8, x3 + 23) axxu71 s: [] p: 9 w: max(x2 + 20) #axxu252 s: [3,1] p: 0 w: max(x1 + 1, x3 + 1) axxsel s: [1] p: 19 w: x1 + x2 + 30302 u72 s: [] p: 9 w: max(x2 + 17) u21 s: [2] p: 19 w: max(x2, x3 + 15019) u201 s: [] p: 18 w: max(x1 + 105) u262 s: [] p: 18 w: 0 axxu52 s: [3,2] p: 18 w: max(x2 + 2, x3) u331 s: [2,1] p: 0 w: max(x1 + 13417, x2 + 10, x3 + 13417) axxu122 s: [] p: 14 w: 3 u93 s: [] p: 17 w: x1 + 4390 u206 s: [] p: 18 w: 0 #axxu291 s: [] p: 0 w: 0 #axxu253 s: [2] p: 0 w: max(x2, x3) isLNatKind s: [] p: 12 w: 34 u272 s: [] p: 23 w: 0 u255 s: [1] p: 10 w: max(x1 + 2) #axxu52 s: [] p: 0 w: max(x3) axxu326 s: [] p: 14 w: max(x1 + 1, x2 + 16271, x3 + 22, x4 + 16255) axxfst s: [1] p: 19 w: x1 axxu61 s: [] p: 1 w: max(x2 + 3) u43 s: [] p: 19 w: max(x2 + 58, x3 + 89) axxu111 s: [] p: 12 w: max(x1 + 5) axxu321 s: [] p: 20 w: max(x2 + 16271, x3 + 16273, x4 + 16255) u183 s: [] p: 17 w: 0 axxu106 s: [] p: 17 w: 1 axxu171 s: [1] p: 11 w: x1 + 7 axxu282 s: [] p: 22 w: max(x2 + 21) #axxu331 s: [] p: 0 w: max(x1) u82 s: [] p: 15 w: max(x2) #_ s: [2] p: 0 w: x2 u161 s: 1 #axxu31 s: [3,2] p: 0 w: x2 + x3 u204 s: [] p: 18 w: max(x1 + 8) axxisNaturalKind s: [] p: 12 w: 26 #axxu46 s: [] p: 0 w: 1 #axxsel s: [] p: 0 w: x2 + 1 u321 s: [] p: 20 w: max(x2 + 16271, x3 + 16273, x4 + 16255) axxu241 s: [1] p: 2 w: max(x1 + 14985, x3 + 14985) #axxu42 s: [3,1] p: 0 w: max(x1, x3) axxu325 s: [] p: 15 w: max(x1 + 10, x2 + 16271, x3 + 23, x4 + 16255) axxu51 s: [3] p: 15 w: max(x2 + 3, x3 + 1) u171 s: [1] p: 11 w: x1 + 7 u334 s: 2 #axxu323 s: [2] p: 12 w: max(x2 + 264) axxu221 s: [] p: 18 w: 18 head s: [] p: 18 w: x1 + 134 u34 s: [2] p: 0 w: max(x2) #axxu13 s: [] p: 0 w: x1 axxu92 s: [1,2] p: 7 w: max(x1, x2 + 13546) u245 s: [] p: 10 w: max(x2 + 3) cons s: [] p: 12 w: max(x1 + 20, x2) #axxu104 s: [1,2] p: 0 w: max(x1 + 1, x2 + 1) u311 s: [] p: 21 w: max(x2 + 15983) axxu303 s: [] p: 18 w: max(x1 + 2, x2 + 4) axxu45 s: [] p: 1 w: max(x2 + 84) snd s: [1] p: 22 w: x1 + 13 #axxu41 s: [2,3] p: 0 w: max(x2, x3 + 1) u22 s: [2] p: 19 w: max(x2, x3 + 15019) u281 s: [] p: 23 w: max(x2 + 21) axxu54 s: [] p: 18 w: max(x2) axxu105 s: [] p: 14 w: max(x1 + 3) axxu206 s: [] p: 18 w: 0 axxu12 s: [] p: 23 w: max(x2 + 29886, x3 + 29892) axxu254 s: [] p: 12 w: max(x1 + 135) axxtail s: [1] p: 10 w: x1 + 13550 u112 s: [] p: 8 w: 5 u42 s: [] p: 9 w: max(x1 + 22337, x2 + 20132, x3 + 90) tt s: [] p: 17 w: 0 u55 s: [] p: 18 w: 0 #axxu243 s: [] p: 0 w: max(x3 + 1) #axxu191 s: [] p: 0 w: max(x2 + 1) #axxu231 s: [] p: 0 w: x2 #axxu131 s: [] p: 0 w: 0 axxu42 s: [] p: 9 w: max(x1 + 22337, x2 + 20132, x3 + 90) #axxu304 s: [] p: 0 w: x2 axxu251 s: [] p: 14 w: max(x1 + 60, x3 + 16254) u343 s: [1,2] p: 23 w: max(x1 + 25969, x2 + 23780, x3 + 31965) u232 s: [] p: 10 w: 2 axxu271 s: [] p: 23 w: 0 #axxu281 s: [] p: 0 w: 1 #axxu241 s: [3,2,1] p: 0 w: max(x1, x2, x3 + 1) axxisLNatKind s: [] p: 12 w: 34 axxu161 s: 1 axxu262 s: [] p: 18 w: 0 axxu202 s: [] p: 18 w: max(x1 + 79) #axxu53 s: [] p: 0 w: max(x2 + 1) u242 s: [3] p: 1 w: max(x3 + 10077) u71 s: [] p: 9 w: max(x2 + 20) #axxu255 s: [1] p: 0 w: max(x1) axxu231 s: [] p: 10 w: 24 axxu93 s: [] p: 17 w: x1 + 4390 axxtake s: [] p: 25 w: x1 + x2 + 35471 #axxu61 s: [1,2] p: 0 w: max(x1 + 1, x2 + 1) axxu53 s: [] p: 18 w: max(x2 + 1) #axxfst s: [] p: 0 w: 1 #axxu171 s: [] p: 0 w: 0 axxu101 s: [] p: 15 w: max(x1 + 35444) u231 s: [] p: 10 w: 24 #axxu71 s: [2] p: 0 w: max(x2) axxu256 s: [] p: 18 w: 0 #axxisNatural s: [] p: 0 w: 1 #axxu63 s: [] p: 0 w: 1 #axxu34 s: [] p: 0 w: 1 u193 s: [] p: 17 w: 0 #axxu24 s: [] p: 0 w: 1 axxu272 s: [] p: 23 w: 0 axxu112 s: [] p: 8 w: 5 u31 s: [] p: 2 w: max(x2 + 145, x3 + 51) axxu34 s: [2] p: 0 w: max(x2) u141 s: [] p: 12 w: 17 u44 s: [] p: 18 w: max(x2 + 33, x3 + 88) axxu322 s: [2,3,4] p: 19 w: max(x2 + 16271, x3 + 16272, x4 + 16255) axxu21 s: [2] p: 19 w: max(x2, x3 + 15019) #axxu182 s: [] p: 0 w: max(x2 + 1) #axxu203 s: [1,3,2] p: 0 w: max(x1 + 1, x2 + 1, x3) #axxtake s: [] p: 0 w: 1 #axxu293 s: [] p: 0 w: max(x1) #axxu282 s: [] p: 0 w: x1 + 1 axxu43 s: [] p: 19 w: max(x2 + 58, x3 + 89) u256 s: [] p: 18 w: 0 #axxhead s: [] p: 0 w: 0 u326 s: [] p: 14 w: max(x1 + 1, x2 + 16271, x3 + 22, x4 + 16255) axxhead s: [] p: 18 w: x1 + 134 u254 s: [] p: 12 w: max(x1 + 135) USABLE RULES: { 1..407 } Removed DPs: #72 Number of SCCs: 1, DPs: 24 SCC { #10 #21 #35 #61 #65 #83 #94 #96 #108 #119 #133 #161 #191 #220 #232 #254 #268 #365 #393 #395 #415 #419 #446 #482 } POLO(Sum)... succeeded. #axxu172 w: 0 u81 w: x1 + 1 #axxu256 w: 0 #axxu51 w: 3914 u327 w: x1 + 1 axxu104 w: x2 + x3 + 4 #axxu246 w: 0 u83 w: 1 #axxu122 w: 0 #axxu311 w: 2 axxu302 w: 31 u172 w: 1 axxu245 w: 1 u244 w: 1 u292 w: x1 + 5 #axxu32 w: 0 u13 w: 10 axxu13 w: x1 + x3 + 9 u62 w: x1 + 6 #axxu327 w: 2 axxu232 w: 9199 #axxu244 w: 3914 u341 w: x2 + x3 + 1 #axxu141 w: 0 axxu211 w: 10 #axxu254 w: 3915 axxu62 w: x1 + 6 u253 w: x1 + x2 + x3 + 4 #axxu103 w: 4219 u344 w: 5 s w: x1 + 3 u241 w: x1 + x2 + 13 axxu253 w: 3 u322 w: x2 + x3 + x4 + 1 axxisLNat w: x1 + 4 axxu324 w: x1 u304 w: x1 + 2 #axxu12 w: 2 axxu121 w: 0 u91 w: 1 #axxu111 w: 0 axxu311 w: x1 + 1 axxisPLNatKind w: x1 + 4 #axxu14 w: 2 u246 w: 1 #axxu192 w: 3915 axxu327 w: x1 u261 w: x1 + 20 axxu63 w: x1 + 18 u53 w: x1 + x2 + 1001 isPLNatKind w: 5 u111 w: x1 + x2 + 5 #axxu211 w: 0 #axxu82 w: 3911 axxu46 w: x1 + 1 u23 w: 1 u104 w: x1 + x3 + 5 #axxu92 w: 3912 axxu131 w: x1 axxu294 w: x1 + x2 + x3 + 1 u191 w: 1 axxu252 w: x2 + x3 + 5 isPLNat w: 1 axxsnd w: 22 u102 w: x1 + x3 + 3 axxu191 w: 3 #axxu271 w: 0 axxu11 w: x2 + 4 u121 w: x1 + x2 + 8443 #axxu206 w: 0 #axxu312 w: 2 axxu32 w: x1 axxu172 w: 5 #axxu102 w: 4220 #axxu193 w: 0 #axxu101 w: 4221 #axxu341 w: 0 #axxu181 w: 5340 u181 w: 1 #axxisLNat w: 3912 u243 w: 1 axxu55 w: x2 + 3 take w: x2 + 1 u105 w: 1 #axxu93 w: 0 u293 w: x1 + 3712 #axxu204 w: 2 u122 w: x1 + 1018 axxu255 w: x1 + 1 u302 w: x1 + x2 + 32 #axxu322 w: 1 axxsplitAt w: x1 + 1 u103 w: x1 + 4 #axxu221 w: 0 #axxu324 w: 1 #axxu55 w: 0 #axxu302 w: 0 u205 w: x1 + x2 + 4 axxu33 w: x3 + 12 axxu242 w: x2 + x3 + 24 axxu304 w: 1 u54 w: x1 + x2 + 1974 axxu312 w: x2 + 13 pair w: 14 axxu91 w: 5 fst w: 9 axxu56 w: 3 #axxu151 w: 0 u24 w: x1 + x2 + 14 u131 w: 1 u252 w: x1 + 6 #axxu303 w: 0 u282 w: x1 + 8538 natsFrom w: 4 u303 w: x2 + 29 u182 w: x1 + 3 #axxu326 w: 0 axxu261 w: x2 + 19 #axxu245 w: 3913 axxu103 w: x3 + 3 u294 w: 1 u251 w: 4 #axxu242 w: 3916 u332 w: 1 u33 w: x2 + 13 axxu14 w: x2 + 21 #axxu23 w: 2 #axxu183 w: 0 u323 w: x3 + x4 + 2 #axxu334 w: 2 #axxu54 w: 3914 splitAt w: x1 + x2 + 2 u192 w: 3 #axxu301 w: 0 #axxu332 w: 2 isNaturalKind w: 1 #axxu11 w: 2 u52 w: 1 axxu201 w: x1 + x2 + 1 #axxu333 w: 2 #axxu325 w: 0 #axxu232 w: 0 u291 w: x2 + x3 + 4 axxu102 w: 2 u61 w: 1 #axxu43 w: 1 u92 w: 1 axxu83 w: x1 + 2 axxu31 w: 4 #axxu83 w: 0 axxu72 w: x1 + x2 + 11 #axxu33 w: 1 u221 w: x1 + 10 axxu203 w: x3 + 3 axxu246 w: x1 + 1 #axxisNaturalKind w: 0 u56 w: x1 + 3321 axxu342 w: x2 + 3 _ w: 0 axxu183 w: 11 axxu281 w: 3 axxu193 w: 3 u324 w: x3 + x4 + 1 axxu192 w: 3 #axxu344 w: 2 u151 w: 2 axxu22 w: 2 #axxu292 w: 2 u202 w: x1 + 1 axxu44 w: x2 + x3 + 5 isNatural w: 5 #axxu294 w: 2 axxu333 w: x2 + 12 #axxu45 w: 0 u106 w: x1 + 8 axxu24 w: 13 #axxu121 w: 0 axxu341 w: x1 axxu323 w: x1 + 1 axxu344 w: x2 + 12 axxu291 w: 3 #axxsplitAt w: 1 axxnatsFrom w: 3 u41 w: x1 + 5415 #axxu343 w: 2 axxisNatural w: 4 u211 w: x1 + 11 axxu151 w: 1 u45 w: x1 + 6 #axxu321 w: 1 u63 w: x1 + 18 #axxu112 w: 0 axxu181 w: x1 + 1 axxu23 w: x1 + 1 #axxu91 w: 9430 #axxu205 w: 3914 #axxu56 w: 0 u342 w: x1 + x3 + 4 #axxu201 w: 3917 axxu334 w: x1 + 2 tail w: x1 u51 w: x1 + x3 + 1590 #axxu342 w: 2 #axxafterNth w: 2 #axxu44 w: 3914 #mark w: x1 + 2 #axxtail w: 0 u271 w: x1 + 5836 0 w: 3 axxu82 w: 1 axxu244 w: x1 + x2 + x3 + 1 axxu243 w: 2 #axxnatsFrom w: 2 axxu141 w: x1 + 2 axxisPLNat w: x1 #axxu72 w: 3914 axxu81 w: x1 + 24 #axxisPLNat w: 3910 u333 w: x1 + 13 #axxu106 w: 0 #axxu251 w: 3918 axxu182 w: 2 u11 w: x1 + 5 sel w: 9186 axxu204 w: x1 u312 w: x1 + 14 #axxisLNatKind w: 309 axxu301 w: x1 + 19 u32 w: x2 + 1 axxu292 w: x3 + 4 u73 w: 23 #axxu272 w: 0 afterNth w: 5409 #axxisPLNatKind w: 628 #axxu62 w: 0 #axxu161 w: 0 axxu293 w: x3 + 3 u46 w: 2 #axxu261 w: 310 axxu73 w: 23 u14 w: 21 nil w: 5 #axxsnd w: 0 axxu343 w: x1 u325 w: x1 + x2 + x3 + x4 + 3 isLNat w: 4 #axxu21 w: 2 axxu41 w: x2 + x3 + 5414 #axxu105 w: 2 #axxu202 w: 3916 axxafterNth w: 3 #axxu262 w: 0 u12 w: 1 mark w: 2 axxu332 w: x1 axxu205 w: 3 u203 w: 1 #axxu22 w: 2 u101 w: 5 #axxu73 w: 0 #axxu81 w: 0 axxu331 w: x1 + x2 + 5 u301 w: 20 axxu71 w: x1 + 4 #axxu252 w: 3917 axxsel w: x2 + 3 u72 w: x1 + 10 u21 w: 1 u201 w: x1 + 1 u262 w: x1 + 18 axxu52 w: 1 u331 w: x1 + x3 + 2068 axxu122 w: 0 u93 w: 1 u206 w: x1 + 4 #axxu291 w: 2 #axxu253 w: 3916 isLNatKind w: x1 + 4 u272 w: x1 + 9 u255 w: x1 + x2 + 3277 #axxu52 w: 3914 axxu326 w: x2 + x3 + 6 axxfst w: x1 + 9 axxu61 w: x2 + 14 u43 w: 2 axxu111 w: 4 axxu321 w: x2 + x3 + 5 u183 w: 1 axxu106 w: 7 axxu171 w: 4 axxu282 w: x1 #axxu331 w: 2 u82 w: x1 + x2 + 2 #_ w: 0 u161 w: x1 + 2 #axxu31 w: 2 u204 w: x1 + x3 + 1 axxisNaturalKind w: x1 + 5 #axxu46 w: 0 #axxsel w: 2 u321 w: x4 + 6 axxu241 w: x1 + x3 + 12 #axxu42 w: 3914 axxu325 w: 2 axxu51 w: 1 u171 w: x1 + x2 + 5 u334 w: 3 #axxu323 w: 0 axxu221 w: 9 head w: x1 + 4 u34 w: x2 + 3 #axxu13 w: 2 axxu92 w: x2 + 1 u245 w: x1 + x2 + 2 cons w: x2 + 7 #axxu104 w: 4218 u311 w: x2 + 2 axxu303 w: x1 + 28 axxu45 w: x2 + 5 snd w: 23 #axxu41 w: 3914 u22 w: 1 u281 w: x1 + x2 + 4 axxu54 w: 2 axxu105 w: x2 + 4 axxu206 w: 3 axxu12 w: x1 + x2 + x3 + 1 axxu254 w: x1 + x2 + 1 axxtail w: x1 + 1 u112 w: 6 u42 w: x1 + x2 + x3 + 2354 tt w: 11 u55 w: x1 + 5342 #axxu243 w: 3915 #axxu191 w: 3915 #axxu231 w: 0 #axxu131 w: 0 axxu42 w: 2 #axxu304 w: 1 axxu251 w: 4 u343 w: x2 + 1 u232 w: x1 + 9200 axxu271 w: x2 + 7 #axxu281 w: 2 #axxu241 w: 3917 axxisLNatKind w: 3 axxu161 w: x1 + 1 axxu262 w: x1 + 17 axxu202 w: x1 + x2 + 8 #axxu53 w: 3914 u242 w: x1 + 25 u71 w: x1 + 4 #axxu255 w: 3913 axxu231 w: x1 + x2 + 9187 axxu93 w: 2 axxtake w: x2 + 1 #axxu61 w: 3914 axxu53 w: x3 + 3 #axxfst w: 2 #axxu171 w: 0 axxu101 w: x2 + x3 + 6 u231 w: x1 + 5 #axxu71 w: 3914 axxu256 w: 2 #axxisNatural w: 3914 #axxu63 w: 0 #axxu34 w: 2 u193 w: x1 + 141 #axxu24 w: 2 axxu272 w: 8 axxu112 w: 5 u31 w: x3 + 5 axxu34 w: 2 u141 w: x1 + 3 u44 w: 4 axxu322 w: x1 axxu21 w: 2 #axxu182 w: 5340 #axxu203 w: 3916 #axxtake w: 0 #axxu293 w: 2 #axxu282 w: 2 axxu43 w: x2 + x3 + 3 u256 w: x1 + 7229 #axxhead w: 0 u326 w: 6 axxhead w: 3 u254 w: x1 + 1 USABLE RULES: { 23 310 } Removed DPs: #10 #21 #35 #61 #65 #83 #94 #96 #108 #119 #133 #161 #191 #220 #232 #254 #268 #365 #393 #395 #415 #419 #446 #482 Number of SCCs: 0, DPs: 0 >>YES ******** Signature ******** map : ((A -> A),A) -> A nil : A app : ((A -> A),A) -> A ******** Computation rules ******** (408) map(%X.Z125[%X],nil) => nil (409) %Y.G125[%Y]@V125 => G125[V125] ******** General Schema criterion ******** Found constructors: 0, afterNth, cons, fst, head, isLNat, isLNatKind, isNatural, isNaturalKind, isPLNat, isPLNatKind, natsFrom, nil, pair, s, sel, snd, splitAt, tail, take, tt, u101, u102, u103, u104, u105, u106, u11, u111, u112, u12, u121, u122, u13, u131, u14, u141, u151, u161, u171, u172, u181, u182, u183, u191, u192, u193, u201, u202, u203, u204, u205, u206, u21, u211, u22, u221, u23, u231, u232, u24, u241, u242, u243, u244, u245, u246, u251, u252, u253, u254, u255, u256, u261, u262, u271, u272, u281, u282, u291, u292, u293, u294, u301, u302, u303, u304, u31, u311, u312, u32, u321, u322, u323, u324, u325, u326, u327, u33, u331, u332, u333, u334, u34, u341, u342, u343, u344, u41, u42, u43, u44, u45, u46, u51, u52, u53, u54, u55, u56, u61, u62, u63, u71, u72, u73, u81, u82, u83, u91, u92, u93 Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>Regared as equal: mark, axxsel, axxisNatural, axxu201, axxisNaturalKind, axxu231, axxisLNatKind, axxu171 Checking (1) axxu101(tt,X,Y) => axxu102(axxisNaturalKind(X),X,Y) (fun axxu101>axxu102) (fun axxu101>axxisNaturalKind) (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (meta Y)[is acc in tt,X,Y] [is positive in tt] [is acc in Y] >>True Checking (2) axxu102(tt,U,V) => axxu103(axxisLNatKind(V),U,V) (fun axxu102>axxu103) (fun axxu102>axxisLNatKind) (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] (meta U)[is acc in tt,U,V] [is positive in tt] [is acc in U] (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] >>True Checking (3) axxu103(tt,W,P) => axxu104(axxisLNatKind(P),W,P) (fun axxu103>axxu104) (fun axxu103>axxisLNatKind) (meta P)[is acc in tt,W,P] [is positive in tt] [is acc in P] (meta W)[is acc in tt,W,P] [is positive in tt] [is acc in W] (meta P)[is acc in tt,W,P] [is positive in tt] [is acc in P] >>True Checking (4) axxu104(tt,X1,Y1) => axxu105(axxisNatural(X1),Y1) (fun axxu104>axxu105) (fun axxu104>axxisNatural) (meta X1)[is acc in tt,X1,Y1] [is positive in tt] [is acc in X1] (meta Y1)[is acc in tt,X1,Y1] [is positive in tt] [is acc in Y1] >>True Checking (5) axxu105(tt,U1) => axxu106(axxisLNat(U1)) (fun axxu105>axxu106) (fun axxu105>axxisLNat) (meta U1)[is acc in tt,U1] [is positive in tt] [is acc in U1] >>True Checking (6) axxu106(tt) => tt (fun axxu106>tt) >>True Checking (7) axxu11(tt,V1,W1) => axxu12(axxisNaturalKind(V1),V1,W1) (fun axxu11>axxu12) (fun axxu11>axxisNaturalKind) (meta V1)[is acc in tt,V1,W1] [is positive in tt] [is acc in V1] (meta V1)[is acc in tt,V1,W1] [is positive in tt] [is acc in V1] (meta W1)[is acc in tt,V1,W1] [is positive in tt] [is acc in W1] >>True Checking (8) axxu111(tt,P1) => axxu112(axxisLNatKind(P1)) (fun axxu111>axxu112) (fun axxu111>axxisLNatKind) (meta P1)[is acc in tt,P1] [is positive in tt] [is acc in P1] >>True Checking (9) axxu112(tt) => tt (fun axxu112>tt) >>True Checking (10) axxu12(tt,X2,Y2) => axxu13(axxisLNat(Y2),X2,Y2) (fun axxu12>axxu13) (fun axxu12>axxisLNat) (meta Y2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in Y2] (meta X2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in X2] (meta Y2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in Y2] >>True Checking (11) axxu121(tt,U2) => axxu122(axxisLNatKind(U2)) (fun axxu121>axxu122) (fun axxu121>axxisLNatKind) (meta U2)[is acc in tt,U2] [is positive in tt] [is acc in U2] >>True Checking (12) axxu122(tt) => tt (fun axxu122>tt) >>True Checking (13) axxu13(tt,V2,W2) => axxu14(axxisLNatKind(W2),V2,W2) (fun axxu13>axxu14) (fun axxu13>axxisLNatKind) (meta W2)[is acc in tt,V2,W2] [is positive in tt] [is acc in W2] (meta V2)[is acc in tt,V2,W2] [is positive in tt] [is acc in V2] (meta W2)[is acc in tt,V2,W2] [is positive in tt] [is acc in W2] >>True Checking (14) axxu131(tt) => tt (fun axxu131>tt) >>True Checking (15) axxu14(tt,P2,X3) => axxsnd(axxsplitAt(mark(P2),mark(X3))) (fun axxu14>axxsnd) (fun axxu14>axxsplitAt) (fun axxu14>mark) (meta P2)[is acc in tt,P2,X3] [is positive in tt] [is acc in P2] (fun axxu14>mark) (meta X3)[is acc in tt,P2,X3] [is positive in tt] [is acc in X3] >>True Checking (16) axxu141(tt) => tt (fun axxu141>tt) >>True Checking (17) axxu151(tt) => tt (fun axxu151>tt) >>True Checking (18) axxu161(tt) => tt (fun axxu161>tt) >>True Checking (19) axxu171(tt,Y3) => axxu172(axxisLNatKind(Y3)) (fun axxu171>axxu172) (fun axxu171=axxisLNatKind) subterm comparison of args w. LR LR >>False Try again using status RL Checking (1) axxu101(tt,X,Y) => axxu102(axxisNaturalKind(X),X,Y) (fun axxu101>axxu102) (fun axxu101>axxisNaturalKind) (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (meta Y)[is acc in tt,X,Y] [is positive in tt] [is acc in Y] >>True Checking (2) axxu102(tt,U,V) => axxu103(axxisLNatKind(V),U,V) (fun axxu102>axxu103) (fun axxu102>axxisLNatKind) (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] (meta U)[is acc in tt,U,V] [is positive in tt] [is acc in U] (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] >>True Checking (3) axxu103(tt,W,P) => axxu104(axxisLNatKind(P),W,P) (fun axxu103>axxu104) (fun axxu103>axxisLNatKind) (meta P)[is acc in tt,W,P] [is positive in tt] [is acc in P] (meta W)[is acc in tt,W,P] [is positive in tt] [is acc in W] (meta P)[is acc in tt,W,P] [is positive in tt] [is acc in P] >>True Checking (4) axxu104(tt,X1,Y1) => axxu105(axxisNatural(X1),Y1) (fun axxu104>axxu105) (fun axxu104>axxisNatural) (meta X1)[is acc in tt,X1,Y1] [is positive in tt] [is acc in X1] (meta Y1)[is acc in tt,X1,Y1] [is positive in tt] [is acc in Y1] >>True Checking (5) axxu105(tt,U1) => axxu106(axxisLNat(U1)) (fun axxu105>axxu106) (fun axxu105>axxisLNat) (meta U1)[is acc in tt,U1] [is positive in tt] [is acc in U1] >>True Checking (6) axxu106(tt) => tt (fun axxu106>tt) >>True Checking (7) axxu11(tt,V1,W1) => axxu12(axxisNaturalKind(V1),V1,W1) (fun axxu11>axxu12) (fun axxu11>axxisNaturalKind) (meta V1)[is acc in tt,V1,W1] [is positive in tt] [is acc in V1] (meta V1)[is acc in tt,V1,W1] [is positive in tt] [is acc in V1] (meta W1)[is acc in tt,V1,W1] [is positive in tt] [is acc in W1] >>True Checking (8) axxu111(tt,P1) => axxu112(axxisLNatKind(P1)) (fun axxu111>axxu112) (fun axxu111>axxisLNatKind) (meta P1)[is acc in tt,P1] [is positive in tt] [is acc in P1] >>True Checking (9) axxu112(tt) => tt (fun axxu112>tt) >>True Checking (10) axxu12(tt,X2,Y2) => axxu13(axxisLNat(Y2),X2,Y2) (fun axxu12>axxu13) (fun axxu12>axxisLNat) (meta Y2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in Y2] (meta X2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in X2] (meta Y2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in Y2] >>True Checking (11) axxu121(tt,U2) => axxu122(axxisLNatKind(U2)) (fun axxu121>axxu122) (fun axxu121>axxisLNatKind) (meta U2)[is acc in tt,U2] [is positive in tt] [is acc in U2] >>True Checking (12) axxu122(tt) => tt (fun axxu122>tt) >>True Checking (13) axxu13(tt,V2,W2) => axxu14(axxisLNatKind(W2),V2,W2) (fun axxu13>axxu14) (fun axxu13>axxisLNatKind) (meta W2)[is acc in tt,V2,W2] [is positive in tt] [is acc in W2] (meta V2)[is acc in tt,V2,W2] [is positive in tt] [is acc in V2] (meta W2)[is acc in tt,V2,W2] [is positive in tt] [is acc in W2] >>True Checking (14) axxu131(tt) => tt (fun axxu131>tt) >>True Checking (15) axxu14(tt,P2,X3) => axxsnd(axxsplitAt(mark(P2),mark(X3))) (fun axxu14>axxsnd) (fun axxu14>axxsplitAt) (fun axxu14>mark) (meta P2)[is acc in tt,P2,X3] [is positive in tt] [is acc in P2] (fun axxu14>mark) (meta X3)[is acc in tt,P2,X3] [is positive in tt] [is acc in X3] >>True Checking (16) axxu141(tt) => tt (fun axxu141>tt) >>True Checking (17) axxu151(tt) => tt (fun axxu151>tt) >>True Checking (18) axxu161(tt) => tt (fun axxu161>tt) >>True Checking (19) axxu171(tt,Y3) => axxu172(axxisLNatKind(Y3)) (fun axxu171>axxu172) (fun axxu171=axxisLNatKind) subterm comparison of args w. RL RL >>False Try again using status Mul Checking (1) axxu101(tt,X,Y) => axxu102(axxisNaturalKind(X),X,Y) (fun axxu101>axxu102) (fun axxu101>axxisNaturalKind) (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (meta Y)[is acc in tt,X,Y] [is positive in tt] [is acc in Y] >>True Checking (2) axxu102(tt,U,V) => axxu103(axxisLNatKind(V),U,V) (fun axxu102>axxu103) (fun axxu102>axxisLNatKind) (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] (meta U)[is acc in tt,U,V] [is positive in tt] [is acc in U] (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] >>True Checking (3) axxu103(tt,W,P) => axxu104(axxisLNatKind(P),W,P) (fun axxu103>axxu104) (fun axxu103>axxisLNatKind) (meta P)[is acc in tt,W,P] [is positive in tt] [is acc in P] (meta W)[is acc in tt,W,P] [is positive in tt] [is acc in W] (meta P)[is acc in tt,W,P] [is positive in tt] [is acc in P] >>True Checking (4) axxu104(tt,X1,Y1) => axxu105(axxisNatural(X1),Y1) (fun axxu104>axxu105) (fun axxu104>axxisNatural) (meta X1)[is acc in tt,X1,Y1] [is positive in tt] [is acc in X1] (meta Y1)[is acc in tt,X1,Y1] [is positive in tt] [is acc in Y1] >>True Checking (5) axxu105(tt,U1) => axxu106(axxisLNat(U1)) (fun axxu105>axxu106) (fun axxu105>axxisLNat) (meta U1)[is acc in tt,U1] [is positive in tt] [is acc in U1] >>True Checking (6) axxu106(tt) => tt (fun axxu106>tt) >>True Checking (7) axxu11(tt,V1,W1) => axxu12(axxisNaturalKind(V1),V1,W1) (fun axxu11>axxu12) (fun axxu11>axxisNaturalKind) (meta V1)[is acc in tt,V1,W1] [is positive in tt] [is acc in V1] (meta V1)[is acc in tt,V1,W1] [is positive in tt] [is acc in V1] (meta W1)[is acc in tt,V1,W1] [is positive in tt] [is acc in W1] >>True Checking (8) axxu111(tt,P1) => axxu112(axxisLNatKind(P1)) (fun axxu111>axxu112) (fun axxu111>axxisLNatKind) (meta P1)[is acc in tt,P1] [is positive in tt] [is acc in P1] >>True Checking (9) axxu112(tt) => tt (fun axxu112>tt) >>True Checking (10) axxu12(tt,X2,Y2) => axxu13(axxisLNat(Y2),X2,Y2) (fun axxu12>axxu13) (fun axxu12>axxisLNat) (meta Y2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in Y2] (meta X2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in X2] (meta Y2)[is acc in tt,X2,Y2] [is positive in tt] [is acc in Y2] >>True Checking (11) axxu121(tt,U2) => axxu122(axxisLNatKind(U2)) (fun axxu121>axxu122) (fun axxu121>axxisLNatKind) (meta U2)[is acc in tt,U2] [is positive in tt] [is acc in U2] >>True Checking (12) axxu122(tt) => tt (fun axxu122>tt) >>True Checking (13) axxu13(tt,V2,W2) => axxu14(axxisLNatKind(W2),V2,W2) (fun axxu13>axxu14) (fun axxu13>axxisLNatKind) (meta W2)[is acc in tt,V2,W2] [is positive in tt] [is acc in W2] (meta V2)[is acc in tt,V2,W2] [is positive in tt] [is acc in V2] (meta W2)[is acc in tt,V2,W2] [is positive in tt] [is acc in W2] >>True Checking (14) axxu131(tt) => tt (fun axxu131>tt) >>True Checking (15) axxu14(tt,P2,X3) => axxsnd(axxsplitAt(mark(P2),mark(X3))) (fun axxu14>axxsnd) (fun axxu14>axxsplitAt) (fun axxu14>mark) (meta P2)[is acc in tt,P2,X3] [is positive in tt] [is acc in P2] (fun axxu14>mark) (meta X3)[is acc in tt,P2,X3] [is positive in tt] [is acc in X3] >>True Checking (16) axxu141(tt) => tt (fun axxu141>tt) >>True Checking (17) axxu151(tt) => tt (fun axxu151>tt) >>True Checking (18) axxu161(tt) => tt (fun axxu161>tt) >>True Checking (19) axxu171(tt,Y3) => axxu172(axxisLNatKind(Y3)) (fun axxu171>axxu172) (fun axxu171=axxisLNatKind) subterm comparison of args w. Mul Mul (meta Y3)[is acc in tt,Y3] [is positive in tt] [is acc in Y3] >>True Checking (20) axxu172(tt) => tt (fun axxu172>tt) >>True Checking (21) axxu181(tt,U3) => axxu182(axxisLNatKind(U3),U3) (fun axxu181>axxu182) (fun axxu181>axxisLNatKind) (meta U3)[is acc in tt,U3] [is positive in tt] [is acc in U3] (meta U3)[is acc in tt,U3] [is positive in tt] [is acc in U3] >>True Checking (22) axxu182(tt,V3) => axxu183(axxisLNat(V3)) (fun axxu182>axxu183) (fun axxu182>axxisLNat) (meta V3)[is acc in tt,V3] [is positive in tt] [is acc in V3] >>True Checking (23) axxu183(tt) => tt (fun axxu183>tt) >>True Checking (24) axxu191(tt,W3) => axxu192(axxisNaturalKind(W3),W3) (fun axxu191>axxu192) (fun axxu191>axxisNaturalKind) (meta W3)[is acc in tt,W3] [is positive in tt] [is acc in W3] (meta W3)[is acc in tt,W3] [is positive in tt] [is acc in W3] >>True Checking (25) axxu192(tt,P3) => axxu193(axxisNatural(P3)) (fun axxu192>axxu193) (fun axxu192>axxisNatural) (meta P3)[is acc in tt,P3] [is positive in tt] [is acc in P3] >>True Checking (26) axxu193(tt) => tt (fun axxu193>tt) >>True Checking (27) axxu201(tt,X4,Y4) => axxu202(axxisNaturalKind(X4),X4,Y4) (fun axxu201>axxu202) (fun axxu201=axxisNaturalKind) subterm comparison of args w. Mul Mul (meta X4)[is acc in tt,X4,Y4] [is positive in tt] [is acc in X4] (meta X4)[is acc in tt,X4,Y4] [is positive in tt] [is acc in X4] (meta Y4)[is acc in tt,X4,Y4] [is positive in tt] [is acc in Y4] >>True Checking (28) axxu202(tt,U4,V4) => axxu203(axxisLNatKind(V4),U4,V4) (fun axxu202>axxu203) (fun axxu202>axxisLNatKind) (meta V4)[is acc in tt,U4,V4] [is positive in tt] [is acc in V4] (meta U4)[is acc in tt,U4,V4] [is positive in tt] [is acc in U4] (meta V4)[is acc in tt,U4,V4] [is positive in tt] [is acc in V4] >>True Checking (29) axxu203(tt,W4,P4) => axxu204(axxisLNatKind(P4),W4,P4) (fun axxu203>axxu204) (fun axxu203>axxisLNatKind) (meta P4)[is acc in tt,W4,P4] [is positive in tt] [is acc in P4] (meta W4)[is acc in tt,W4,P4] [is positive in tt] [is acc in W4] (meta P4)[is acc in tt,W4,P4] [is positive in tt] [is acc in P4] >>True Checking (30) axxu204(tt,X5,Y5) => axxu205(axxisNatural(X5),Y5) (fun axxu204>axxu205) (fun axxu204>axxisNatural) (meta X5)[is acc in tt,X5,Y5] [is positive in tt] [is acc in X5] (meta Y5)[is acc in tt,X5,Y5] [is positive in tt] [is acc in Y5] >>True Checking (31) axxu205(tt,U5) => axxu206(axxisLNat(U5)) (fun axxu205>axxu206) (fun axxu205>axxisLNat) (meta U5)[is acc in tt,U5] [is positive in tt] [is acc in U5] >>True Checking (32) axxu206(tt) => tt (fun axxu206>tt) >>True Checking (33) axxu21(tt,V5,W5) => axxu22(axxisLNatKind(V5),V5,W5) (fun axxu21>axxu22) (fun axxu21>axxisLNatKind) (meta V5)[is acc in tt,V5,W5] [is positive in tt] [is acc in V5] (meta V5)[is acc in tt,V5,W5] [is positive in tt] [is acc in V5] (meta W5)[is acc in tt,V5,W5] [is positive in tt] [is acc in W5] >>True Checking (34) axxu211(tt) => tt (fun axxu211>tt) >>True Checking (35) axxu22(tt,P5,X6) => axxu23(axxisLNat(X6),P5,X6) (fun axxu22>axxu23) (fun axxu22>axxisLNat) (meta X6)[is acc in tt,P5,X6] [is positive in tt] [is acc in X6] (meta P5)[is acc in tt,P5,X6] [is positive in tt] [is acc in P5] (meta X6)[is acc in tt,P5,X6] [is positive in tt] [is acc in X6] >>True Checking (36) axxu221(tt) => tt (fun axxu221>tt) >>True Checking (37) axxu23(tt,Y6,U6) => axxu24(axxisLNatKind(U6),Y6) (fun axxu23>axxu24) (fun axxu23>axxisLNatKind) (meta U6)[is acc in tt,Y6,U6] [is positive in tt] [is acc in U6] (meta Y6)[is acc in tt,Y6,U6] [is positive in tt] [is acc in Y6] >>True Checking (38) axxu231(tt,V6) => axxu232(axxisLNatKind(V6)) (fun axxu231>axxu232) (fun axxu231=axxisLNatKind) subterm comparison of args w. Mul Mul (meta V6)[is acc in tt,V6] [is positive in tt] [is acc in V6] >>True Checking (39) axxu232(tt) => tt (fun axxu232>tt) >>True Checking (40) axxu24(tt,W6) => mark(W6) (fun axxu24>mark) (meta W6)[is acc in tt,W6] [is positive in tt] [is acc in W6] >>True Checking (41) axxu241(tt,P6,X7) => axxu242(axxisLNatKind(P6),P6,X7) (fun axxu241>axxu242) (fun axxu241>axxisLNatKind) (meta P6)[is acc in tt,P6,X7] [is positive in tt] [is acc in P6] (meta P6)[is acc in tt,P6,X7] [is positive in tt] [is acc in P6] (meta X7)[is acc in tt,P6,X7] [is positive in tt] [is acc in X7] >>True Checking (42) axxu242(tt,Y7,U7) => axxu243(axxisLNatKind(U7),Y7,U7) (fun axxu242>axxu243) (fun axxu242>axxisLNatKind) (meta U7)[is acc in tt,Y7,U7] [is positive in tt] [is acc in U7] (meta Y7)[is acc in tt,Y7,U7] [is positive in tt] [is acc in Y7] (meta U7)[is acc in tt,Y7,U7] [is positive in tt] [is acc in U7] >>True Checking (43) axxu243(tt,V7,W7) => axxu244(axxisLNatKind(W7),V7,W7) (fun axxu243>axxu244) (fun axxu243>axxisLNatKind) (meta W7)[is acc in tt,V7,W7] [is positive in tt] [is acc in W7] (meta V7)[is acc in tt,V7,W7] [is positive in tt] [is acc in V7] (meta W7)[is acc in tt,V7,W7] [is positive in tt] [is acc in W7] >>True Checking (44) axxu244(tt,P7,X8) => axxu245(axxisLNat(P7),X8) (fun axxu244>axxu245) (fun axxu244>axxisLNat) (meta P7)[is acc in tt,P7,X8] [is positive in tt] [is acc in P7] (meta X8)[is acc in tt,P7,X8] [is positive in tt] [is acc in X8] >>True Checking (45) axxu245(tt,Y8) => axxu246(axxisLNat(Y8)) (fun axxu245>axxu246) (fun axxu245>axxisLNat) (meta Y8)[is acc in tt,Y8] [is positive in tt] [is acc in Y8] >>True Checking (46) axxu246(tt) => tt (fun axxu246>tt) >>True Checking (47) axxu251(tt,U8,V8) => axxu252(axxisNaturalKind(U8),U8,V8) (fun axxu251>axxu252) (fun axxu251>axxisNaturalKind) (meta U8)[is acc in tt,U8,V8] [is positive in tt] [is acc in U8] (meta U8)[is acc in tt,U8,V8] [is positive in tt] [is acc in U8] (meta V8)[is acc in tt,U8,V8] [is positive in tt] [is acc in V8] >>True Checking (48) axxu252(tt,W8,P8) => axxu253(axxisLNatKind(P8),W8,P8) (fun axxu252>axxu253) (fun axxu252>axxisLNatKind) (meta P8)[is acc in tt,W8,P8] [is positive in tt] [is acc in P8] (meta W8)[is acc in tt,W8,P8] [is positive in tt] [is acc in W8] (meta P8)[is acc in tt,W8,P8] [is positive in tt] [is acc in P8] >>True Checking (49) axxu253(tt,X9,Y9) => axxu254(axxisLNatKind(Y9),X9,Y9) (fun axxu253>axxu254) (fun axxu253>axxisLNatKind) (meta Y9)[is acc in tt,X9,Y9] [is positive in tt] [is acc in Y9] (meta X9)[is acc in tt,X9,Y9] [is positive in tt] [is acc in X9] (meta Y9)[is acc in tt,X9,Y9] [is positive in tt] [is acc in Y9] >>True Checking (50) axxu254(tt,U9,V9) => axxu255(axxisNatural(U9),V9) (fun axxu254>axxu255) (fun axxu254>axxisNatural) (meta U9)[is acc in tt,U9,V9] [is positive in tt] [is acc in U9] (meta V9)[is acc in tt,U9,V9] [is positive in tt] [is acc in V9] >>True Checking (51) axxu255(tt,W9) => axxu256(axxisLNat(W9)) (fun axxu255>axxu256) (fun axxu255>axxisLNat) (meta W9)[is acc in tt,W9] [is positive in tt] [is acc in W9] >>True Checking (52) axxu256(tt) => tt (fun axxu256>tt) >>True Checking (53) axxu261(tt,P9) => axxu262(axxisLNatKind(P9)) (fun axxu261>axxu262) (fun axxu261>axxisLNatKind) (meta P9)[is acc in tt,P9] [is positive in tt] [is acc in P9] >>True Checking (54) axxu262(tt) => tt (fun axxu262>tt) >>True Checking (55) axxu271(tt,X10) => axxu272(axxisLNatKind(X10)) (fun axxu271>axxu272) (fun axxu271>axxisLNatKind) (meta X10)[is acc in tt,X10] [is positive in tt] [is acc in X10] >>True Checking (56) axxu272(tt) => tt (fun axxu272>tt) >>True Checking (57) axxu281(tt,Y10) => axxu282(axxisNaturalKind(Y10),Y10) (fun axxu281>axxu282) (fun axxu281>axxisNaturalKind) (meta Y10)[is acc in tt,Y10] [is positive in tt] [is acc in Y10] (meta Y10)[is acc in tt,Y10] [is positive in tt] [is acc in Y10] >>True Checking (58) axxu282(tt,U10) => cons(mark(U10),natsFrom(s(U10))) (fun axxu282>cons) (fun axxu282>mark) (meta U10)[is acc in tt,U10] [is positive in tt] [is acc in U10] (fun axxu282>natsFrom) (fun axxu282>s) (meta U10)[is acc in tt,U10] [is positive in tt] [is acc in U10] >>True Checking (59) axxu291(tt,V10,W10) => axxu292(axxisNaturalKind(V10),V10,W10) (fun axxu291>axxu292) (fun axxu291>axxisNaturalKind) (meta V10)[is acc in tt,V10,W10] [is positive in tt] [is acc in V10] (meta V10)[is acc in tt,V10,W10] [is positive in tt] [is acc in V10] (meta W10)[is acc in tt,V10,W10] [is positive in tt] [is acc in W10] >>True Checking (60) axxu292(tt,P10,X11) => axxu293(axxisLNat(X11),P10,X11) (fun axxu292>axxu293) (fun axxu292>axxisLNat) (meta X11)[is acc in tt,P10,X11] [is positive in tt] [is acc in X11] (meta P10)[is acc in tt,P10,X11] [is positive in tt] [is acc in P10] (meta X11)[is acc in tt,P10,X11] [is positive in tt] [is acc in X11] >>True Checking (61) axxu293(tt,Y11,U11) => axxu294(axxisLNatKind(U11),Y11,U11) (fun axxu293>axxu294) (fun axxu293>axxisLNatKind) (meta U11)[is acc in tt,Y11,U11] [is positive in tt] [is acc in U11] (meta Y11)[is acc in tt,Y11,U11] [is positive in tt] [is acc in Y11] (meta U11)[is acc in tt,Y11,U11] [is positive in tt] [is acc in U11] >>True Checking (62) axxu294(tt,V11,W11) => axxhead(axxafterNth(mark(V11),mark(W11))) (fun axxu294>axxhead) (fun axxu294>axxafterNth) (fun axxu294>mark) (meta V11)[is acc in tt,V11,W11] [is positive in tt] [is acc in V11] (fun axxu294>mark) (meta W11)[is acc in tt,V11,W11] [is positive in tt] [is acc in W11] >>True Checking (63) axxu301(tt,P11,X12) => axxu302(axxisLNatKind(P11),X12) (fun axxu301>axxu302) (fun axxu301>axxisLNatKind) (meta P11)[is acc in tt,P11,X12] [is positive in tt] [is acc in P11] (meta X12)[is acc in tt,P11,X12] [is positive in tt] [is acc in X12] >>True Checking (64) axxu302(tt,Y12) => axxu303(axxisLNat(Y12),Y12) (fun axxu302>axxu303) (fun axxu302>axxisLNat) (meta Y12)[is acc in tt,Y12] [is positive in tt] [is acc in Y12] (meta Y12)[is acc in tt,Y12] [is positive in tt] [is acc in Y12] >>True Checking (65) axxu303(tt,U12) => axxu304(axxisLNatKind(U12),U12) (fun axxu303>axxu304) (fun axxu303>axxisLNatKind) (meta U12)[is acc in tt,U12] [is positive in tt] [is acc in U12] (meta U12)[is acc in tt,U12] [is positive in tt] [is acc in U12] >>True Checking (66) axxu304(tt,V12) => mark(V12) (fun axxu304>mark) (meta V12)[is acc in tt,V12] [is positive in tt] [is acc in V12] >>True Checking (67) axxu31(tt,W12,P12) => axxu32(axxisNaturalKind(W12),W12,P12) (fun axxu31>axxu32) (fun axxu31>axxisNaturalKind) (meta W12)[is acc in tt,W12,P12] [is positive in tt] [is acc in W12] (meta W12)[is acc in tt,W12,P12] [is positive in tt] [is acc in W12] (meta P12)[is acc in tt,W12,P12] [is positive in tt] [is acc in P12] >>True Checking (68) axxu311(tt,X13) => axxu312(axxisLNatKind(X13),X13) (fun axxu311>axxu312) (fun axxu311>axxisLNatKind) (meta X13)[is acc in tt,X13] [is positive in tt] [is acc in X13] (meta X13)[is acc in tt,X13] [is positive in tt] [is acc in X13] >>True Checking (69) axxu312(tt,Y13) => pair(nil,mark(Y13)) (fun axxu312>pair) (fun axxu312>nil) (fun axxu312>mark) (meta Y13)[is acc in tt,Y13] [is positive in tt] [is acc in Y13] >>True Checking (70) axxu32(tt,U13,V13) => axxu33(axxisLNat(V13),U13,V13) (fun axxu32>axxu33) (fun axxu32>axxisLNat) (meta V13)[is acc in tt,U13,V13] [is positive in tt] [is acc in V13] (meta U13)[is acc in tt,U13,V13] [is positive in tt] [is acc in U13] (meta V13)[is acc in tt,U13,V13] [is positive in tt] [is acc in V13] >>True Checking (71) axxu321(tt,W13,P13,X14) => axxu322(axxisNaturalKind(W13),W13,P13,X14) (fun axxu321>axxu322) (fun axxu321>axxisNaturalKind) (meta W13)[is acc in tt,W13,P13,X14] [is positive in tt] [is acc in W13] (meta W13)[is acc in tt,W13,P13,X14] [is positive in tt] [is acc in W13] (meta P13)[is acc in tt,W13,P13,X14] [is positive in tt] [is acc in P13] (meta X14)[is acc in tt,W13,P13,X14] [is positive in tt] [is acc in X14] >>True Checking (72) axxu322(tt,Y14,U14,V14) => axxu323(axxisNatural(U14),Y14,U14,V14) (fun axxu322>axxu323) (fun axxu322>axxisNatural) (meta U14)[is acc in tt,Y14,U14,V14] [is positive in tt] [is acc in U14] (meta Y14)[is acc in tt,Y14,U14,V14] [is positive in tt] [is acc in Y14] (meta U14)[is acc in tt,Y14,U14,V14] [is positive in tt] [is acc in U14] (meta V14)[is acc in tt,Y14,U14,V14] [is positive in tt] [is acc in V14] >>True Checking (73) axxu323(tt,W14,P14,X15) => axxu324(axxisNaturalKind(P14),W14,P14,X15) (fun axxu323>axxu324) (fun axxu323>axxisNaturalKind) (meta P14)[is acc in tt,W14,P14,X15] [is positive in tt] [is acc in P14] (meta W14)[is acc in tt,W14,P14,X15] [is positive in tt] [is acc in W14] (meta P14)[is acc in tt,W14,P14,X15] [is positive in tt] [is acc in P14] (meta X15)[is acc in tt,W14,P14,X15] [is positive in tt] [is acc in X15] >>True Checking (74) axxu324(tt,Y15,U15,V15) => axxu325(axxisLNat(V15),Y15,U15,V15) (fun axxu324>axxu325) (fun axxu324>axxisLNat) (meta V15)[is acc in tt,Y15,U15,V15] [is positive in tt] [is acc in V15] (meta Y15)[is acc in tt,Y15,U15,V15] [is positive in tt] [is acc in Y15] (meta U15)[is acc in tt,Y15,U15,V15] [is positive in tt] [is acc in U15] (meta V15)[is acc in tt,Y15,U15,V15] [is positive in tt] [is acc in V15] >>True Checking (75) axxu325(tt,W15,P15,X16) => axxu326(axxisLNatKind(X16),W15,P15,X16) (fun axxu325>axxu326) (fun axxu325>axxisLNatKind) (meta X16)[is acc in tt,W15,P15,X16] [is positive in tt] [is acc in X16] (meta W15)[is acc in tt,W15,P15,X16] [is positive in tt] [is acc in W15] (meta P15)[is acc in tt,W15,P15,X16] [is positive in tt] [is acc in P15] (meta X16)[is acc in tt,W15,P15,X16] [is positive in tt] [is acc in X16] >>True Checking (76) axxu326(tt,Y16,U16,V16) => axxu327(axxsplitAt(mark(Y16),mark(V16)),U16) (fun axxu326>axxu327) (fun axxu326>axxsplitAt) (fun axxu326>mark) (meta Y16)[is acc in tt,Y16,U16,V16] [is positive in tt] [is acc in Y16] (fun axxu326>mark) (meta V16)[is acc in tt,Y16,U16,V16] [is positive in tt] [is acc in V16] (meta U16)[is acc in tt,Y16,U16,V16] [is positive in tt] [is acc in U16] >>True Checking (77) axxu327(pair(W16,P16),X17) => pair(cons(mark(X17),W16),mark(P16)) (fun axxu327>pair) (fun axxu327>cons) (fun axxu327>mark) (meta X17)[is acc in pair(W16,P16),X17] [is positive in pair(W16,P16)] [is acc in X17] (meta W16)[is acc in pair(W16,P16),X17] [is positive in pair(W16,P16)] [is acc in W16] (fun axxu327>mark) (meta P16)[is acc in pair(W16,P16),X17] [is positive in pair(W16,P16)] [is acc in P16] >>True Checking (78) axxu33(tt,Y17,U17) => axxu34(axxisLNatKind(U17),Y17) (fun axxu33>axxu34) (fun axxu33>axxisLNatKind) (meta U17)[is acc in tt,Y17,U17] [is positive in tt] [is acc in U17] (meta Y17)[is acc in tt,Y17,U17] [is positive in tt] [is acc in Y17] >>True Checking (79) axxu331(tt,V17,W17) => axxu332(axxisNaturalKind(V17),W17) (fun axxu331>axxu332) (fun axxu331>axxisNaturalKind) (meta V17)[is acc in tt,V17,W17] [is positive in tt] [is acc in V17] (meta W17)[is acc in tt,V17,W17] [is positive in tt] [is acc in W17] >>True Checking (80) axxu332(tt,P17) => axxu333(axxisLNat(P17),P17) (fun axxu332>axxu333) (fun axxu332>axxisLNat) (meta P17)[is acc in tt,P17] [is positive in tt] [is acc in P17] (meta P17)[is acc in tt,P17] [is positive in tt] [is acc in P17] >>True Checking (81) axxu333(tt,X18) => axxu334(axxisLNatKind(X18),X18) (fun axxu333>axxu334) (fun axxu333>axxisLNatKind) (meta X18)[is acc in tt,X18] [is positive in tt] [is acc in X18] (meta X18)[is acc in tt,X18] [is positive in tt] [is acc in X18] >>True Checking (82) axxu334(tt,Y18) => mark(Y18) (fun axxu334>mark) (meta Y18)[is acc in tt,Y18] [is positive in tt] [is acc in Y18] >>True Checking (83) axxu34(tt,U18) => mark(U18) (fun axxu34>mark) (meta U18)[is acc in tt,U18] [is positive in tt] [is acc in U18] >>True Checking (84) axxu341(tt,V18,W18) => axxu342(axxisNaturalKind(V18),V18,W18) (fun axxu341>axxu342) (fun axxu341>axxisNaturalKind) (meta V18)[is acc in tt,V18,W18] [is positive in tt] [is acc in V18] (meta V18)[is acc in tt,V18,W18] [is positive in tt] [is acc in V18] (meta W18)[is acc in tt,V18,W18] [is positive in tt] [is acc in W18] >>True Checking (85) axxu342(tt,P18,X19) => axxu343(axxisLNat(X19),P18,X19) (fun axxu342>axxu343) (fun axxu342>axxisLNat) (meta X19)[is acc in tt,P18,X19] [is positive in tt] [is acc in X19] (meta P18)[is acc in tt,P18,X19] [is positive in tt] [is acc in P18] (meta X19)[is acc in tt,P18,X19] [is positive in tt] [is acc in X19] >>True Checking (86) axxu343(tt,Y19,U19) => axxu344(axxisLNatKind(U19),Y19,U19) (fun axxu343>axxu344) (fun axxu343>axxisLNatKind) (meta U19)[is acc in tt,Y19,U19] [is positive in tt] [is acc in U19] (meta Y19)[is acc in tt,Y19,U19] [is positive in tt] [is acc in Y19] (meta U19)[is acc in tt,Y19,U19] [is positive in tt] [is acc in U19] >>True Checking (87) axxu344(tt,V19,W19) => axxfst(axxsplitAt(mark(V19),mark(W19))) (fun axxu344>axxfst) (fun axxu344>axxsplitAt) (fun axxu344>mark) (meta V19)[is acc in tt,V19,W19] [is positive in tt] [is acc in V19] (fun axxu344>mark) (meta W19)[is acc in tt,V19,W19] [is positive in tt] [is acc in W19] >>True Checking (88) axxu41(tt,P19,X20) => axxu42(axxisNaturalKind(P19),P19,X20) (fun axxu41>axxu42) (fun axxu41>axxisNaturalKind) (meta P19)[is acc in tt,P19,X20] [is positive in tt] [is acc in P19] (meta P19)[is acc in tt,P19,X20] [is positive in tt] [is acc in P19] (meta X20)[is acc in tt,P19,X20] [is positive in tt] [is acc in X20] >>True Checking (89) axxu42(tt,Y20,U20) => axxu43(axxisLNatKind(U20),Y20,U20) (fun axxu42>axxu43) (fun axxu42>axxisLNatKind) (meta U20)[is acc in tt,Y20,U20] [is positive in tt] [is acc in U20] (meta Y20)[is acc in tt,Y20,U20] [is positive in tt] [is acc in Y20] (meta U20)[is acc in tt,Y20,U20] [is positive in tt] [is acc in U20] >>True Checking (90) axxu43(tt,V20,W20) => axxu44(axxisLNatKind(W20),V20,W20) (fun axxu43>axxu44) (fun axxu43>axxisLNatKind) (meta W20)[is acc in tt,V20,W20] [is positive in tt] [is acc in W20] (meta V20)[is acc in tt,V20,W20] [is positive in tt] [is acc in V20] (meta W20)[is acc in tt,V20,W20] [is positive in tt] [is acc in W20] >>True Checking (91) axxu44(tt,P20,X21) => axxu45(axxisNatural(P20),X21) (fun axxu44>axxu45) (fun axxu44>axxisNatural) (meta P20)[is acc in tt,P20,X21] [is positive in tt] [is acc in P20] (meta X21)[is acc in tt,P20,X21] [is positive in tt] [is acc in X21] >>True Checking (92) axxu45(tt,Y21) => axxu46(axxisLNat(Y21)) (fun axxu45>axxu46) (fun axxu45>axxisLNat) (meta Y21)[is acc in tt,Y21] [is positive in tt] [is acc in Y21] >>True Checking (93) axxu46(tt) => tt (fun axxu46>tt) >>True Checking (94) axxu51(tt,U21,V21) => axxu52(axxisNaturalKind(U21),U21,V21) (fun axxu51>axxu52) (fun axxu51>axxisNaturalKind) (meta U21)[is acc in tt,U21,V21] [is positive in tt] [is acc in U21] (meta U21)[is acc in tt,U21,V21] [is positive in tt] [is acc in U21] (meta V21)[is acc in tt,U21,V21] [is positive in tt] [is acc in V21] >>True Checking (95) axxu52(tt,W21,P21) => axxu53(axxisLNatKind(P21),W21,P21) (fun axxu52>axxu53) (fun axxu52>axxisLNatKind) (meta P21)[is acc in tt,W21,P21] [is positive in tt] [is acc in P21] (meta W21)[is acc in tt,W21,P21] [is positive in tt] [is acc in W21] (meta P21)[is acc in tt,W21,P21] [is positive in tt] [is acc in P21] >>True Checking (96) axxu53(tt,X22,Y22) => axxu54(axxisLNatKind(Y22),X22,Y22) (fun axxu53>axxu54) (fun axxu53>axxisLNatKind) (meta Y22)[is acc in tt,X22,Y22] [is positive in tt] [is acc in Y22] (meta X22)[is acc in tt,X22,Y22] [is positive in tt] [is acc in X22] (meta Y22)[is acc in tt,X22,Y22] [is positive in tt] [is acc in Y22] >>True Checking (97) axxu54(tt,U22,V22) => axxu55(axxisNatural(U22),V22) (fun axxu54>axxu55) (fun axxu54>axxisNatural) (meta U22)[is acc in tt,U22,V22] [is positive in tt] [is acc in U22] (meta V22)[is acc in tt,U22,V22] [is positive in tt] [is acc in V22] >>True Checking (98) axxu55(tt,W22) => axxu56(axxisLNat(W22)) (fun axxu55>axxu56) (fun axxu55>axxisLNat) (meta W22)[is acc in tt,W22] [is positive in tt] [is acc in W22] >>True Checking (99) axxu56(tt) => tt (fun axxu56>tt) >>True Checking (100) axxu61(tt,P22) => axxu62(axxisPLNatKind(P22),P22) (fun axxu61>axxu62) (fun axxu61>axxisPLNatKind) (meta P22)[is acc in tt,P22] [is positive in tt] [is acc in P22] (meta P22)[is acc in tt,P22] [is positive in tt] [is acc in P22] >>True Checking (101) axxu62(tt,X23) => axxu63(axxisPLNat(X23)) (fun axxu62>axxu63) (fun axxu62>axxisPLNat) (meta X23)[is acc in tt,X23] [is positive in tt] [is acc in X23] >>True Checking (102) axxu63(tt) => tt (fun axxu63>tt) >>True Checking (103) axxu71(tt,Y23) => axxu72(axxisNaturalKind(Y23),Y23) (fun axxu71>axxu72) (fun axxu71>axxisNaturalKind) (meta Y23)[is acc in tt,Y23] [is positive in tt] [is acc in Y23] (meta Y23)[is acc in tt,Y23] [is positive in tt] [is acc in Y23] >>True Checking (104) axxu72(tt,U23) => axxu73(axxisNatural(U23)) (fun axxu72>axxu73) (fun axxu72>axxisNatural) (meta U23)[is acc in tt,U23] [is positive in tt] [is acc in U23] >>True Checking (105) axxu73(tt) => tt (fun axxu73>tt) >>True Checking (106) axxu81(tt,V23) => axxu82(axxisPLNatKind(V23),V23) (fun axxu81>axxu82) (fun axxu81>axxisPLNatKind) (meta V23)[is acc in tt,V23] [is positive in tt] [is acc in V23] (meta V23)[is acc in tt,V23] [is positive in tt] [is acc in V23] >>True Checking (107) axxu82(tt,W23) => axxu83(axxisPLNat(W23)) (fun axxu82>axxu83) (fun axxu82>axxisPLNat) (meta W23)[is acc in tt,W23] [is positive in tt] [is acc in W23] >>True Checking (108) axxu83(tt) => tt (fun axxu83>tt) >>True Checking (109) axxu91(tt,P23) => axxu92(axxisLNatKind(P23),P23) (fun axxu91>axxu92) (fun axxu91>axxisLNatKind) (meta P23)[is acc in tt,P23] [is positive in tt] [is acc in P23] (meta P23)[is acc in tt,P23] [is positive in tt] [is acc in P23] >>True Checking (110) axxu92(tt,X24) => axxu93(axxisLNat(X24)) (fun axxu92>axxu93) (fun axxu92>axxisLNat) (meta X24)[is acc in tt,X24] [is positive in tt] [is acc in X24] >>True Checking (111) axxu93(tt) => tt (fun axxu93>tt) >>True Checking (112) axxafterNth(Y24,U24) => axxu11(axxisNatural(Y24),Y24,U24) (fun axxafterNth>axxu11) (fun axxafterNth>axxisNatural) (meta Y24)[is acc in Y24,U24] [is acc in Y24] (meta Y24)[is acc in Y24,U24] [is acc in Y24] (meta U24)[is acc in Y24,U24] [is acc in U24] >>True Checking (113) axxfst(pair(V24,W24)) => axxu21(axxisLNat(V24),V24,W24) (fun axxfst>axxu21) (fun axxfst>axxisLNat) (meta V24)[is acc in pair(V24,W24)] [is positive in pair(V24,W24)] [is acc in V24] (meta V24)[is acc in pair(V24,W24)] [is positive in pair(V24,W24)] [is acc in V24] (meta W24)[is acc in pair(V24,W24)] [is positive in pair(V24,W24)] [is acc in W24] >>True Checking (114) axxhead(cons(P24,X25)) => axxu31(axxisNatural(P24),P24,X25) (fun axxhead>axxu31) (fun axxhead>axxisNatural) (meta P24)[is acc in cons(P24,X25)] [is positive in cons(P24,X25)] [is acc in P24] (meta P24)[is acc in cons(P24,X25)] [is positive in cons(P24,X25)] [is acc in P24] (meta X25)[is acc in cons(P24,X25)] [is positive in cons(P24,X25)] [is acc in X25] >>True Checking (115) axxisLNat(nil) => tt (fun axxisLNat>tt) >>True Checking (116) axxisLNat(afterNth(Y25,U25)) => axxu41(axxisNaturalKind(Y25),Y25,U25) (fun axxisLNat>axxu41) (fun axxisLNat>axxisNaturalKind) (meta Y25)[is acc in afterNth(Y25,U25)] [is positive in afterNth(Y25,U25)] [is acc in Y25] (meta Y25)[is acc in afterNth(Y25,U25)] [is positive in afterNth(Y25,U25)] [is acc in Y25] (meta U25)[is acc in afterNth(Y25,U25)] [is positive in afterNth(Y25,U25)] [is acc in U25] >>True Checking (117) axxisLNat(cons(V25,W25)) => axxu51(axxisNaturalKind(V25),V25,W25) (fun axxisLNat>axxu51) (fun axxisLNat>axxisNaturalKind) (meta V25)[is acc in cons(V25,W25)] [is positive in cons(V25,W25)] [is acc in V25] (meta V25)[is acc in cons(V25,W25)] [is positive in cons(V25,W25)] [is acc in V25] (meta W25)[is acc in cons(V25,W25)] [is positive in cons(V25,W25)] [is acc in W25] >>True Checking (118) axxisLNat(fst(P25)) => axxu61(axxisPLNatKind(P25),P25) (fun axxisLNat>axxu61) (fun axxisLNat>axxisPLNatKind) (meta P25)[is acc in fst(P25)] [is positive in fst(P25)] [is acc in P25] (meta P25)[is acc in fst(P25)] [is positive in fst(P25)] [is acc in P25] >>True Checking (119) axxisLNat(natsFrom(X26)) => axxu71(axxisNaturalKind(X26),X26) (fun axxisLNat>axxu71) (fun axxisLNat>axxisNaturalKind) (meta X26)[is acc in natsFrom(X26)] [is positive in natsFrom(X26)] [is acc in X26] (meta X26)[is acc in natsFrom(X26)] [is positive in natsFrom(X26)] [is acc in X26] >>True Checking (120) axxisLNat(snd(Y26)) => axxu81(axxisPLNatKind(Y26),Y26) (fun axxisLNat>axxu81) (fun axxisLNat>axxisPLNatKind) (meta Y26)[is acc in snd(Y26)] [is positive in snd(Y26)] [is acc in Y26] (meta Y26)[is acc in snd(Y26)] [is positive in snd(Y26)] [is acc in Y26] >>True Checking (121) axxisLNat(tail(U26)) => axxu91(axxisLNatKind(U26),U26) (fun axxisLNat>axxu91) (fun axxisLNat>axxisLNatKind) (meta U26)[is acc in tail(U26)] [is positive in tail(U26)] [is acc in U26] (meta U26)[is acc in tail(U26)] [is positive in tail(U26)] [is acc in U26] >>True Checking (122) axxisLNat(take(V26,W26)) => axxu101(axxisNaturalKind(V26),V26,W26) (fun axxisLNat>axxu101) (fun axxisLNat>axxisNaturalKind) (meta V26)[is acc in take(V26,W26)] [is positive in take(V26,W26)] [is acc in V26] (meta V26)[is acc in take(V26,W26)] [is positive in take(V26,W26)] [is acc in V26] (meta W26)[is acc in take(V26,W26)] [is positive in take(V26,W26)] [is acc in W26] >>True Checking (123) axxisLNatKind(nil) => tt (fun axxisLNatKind>tt) >>True Checking (124) axxisLNatKind(afterNth(P26,X27)) => axxu111(axxisNaturalKind(P26),X27) (fun axxisLNatKind>axxu111) (fun axxisLNatKind=axxisNaturalKind) subterm comparison of args w. Mul Mul (meta P26)[is acc in afterNth(P26,X27)] [is positive in afterNth(P26,X27)] [is acc in P26] (meta X27)[is acc in afterNth(P26,X27)] [is positive in afterNth(P26,X27)] [is acc in X27] >>True Checking (125) axxisLNatKind(cons(Y27,U27)) => axxu121(axxisNaturalKind(Y27),U27) (fun axxisLNatKind>axxu121) (fun axxisLNatKind=axxisNaturalKind) subterm comparison of args w. Mul Mul (meta Y27)[is acc in cons(Y27,U27)] [is positive in cons(Y27,U27)] [is acc in Y27] (meta U27)[is acc in cons(Y27,U27)] [is positive in cons(Y27,U27)] [is acc in U27] >>True Checking (126) axxisLNatKind(fst(V27)) => axxu131(axxisPLNatKind(V27)) (fun axxisLNatKind>axxu131) (fun axxisLNatKind>axxisPLNatKind) (meta V27)[is acc in fst(V27)] [is positive in fst(V27)] [is acc in V27] >>True Checking (127) axxisLNatKind(natsFrom(W27)) => axxu141(axxisNaturalKind(W27)) (fun axxisLNatKind>axxu141) (fun axxisLNatKind=axxisNaturalKind) subterm comparison of args w. Mul Mul (meta W27)[is acc in natsFrom(W27)] [is positive in natsFrom(W27)] [is acc in W27] >>True Checking (128) axxisLNatKind(snd(P27)) => axxu151(axxisPLNatKind(P27)) (fun axxisLNatKind>axxu151) (fun axxisLNatKind>axxisPLNatKind) (meta P27)[is acc in snd(P27)] [is positive in snd(P27)] [is acc in P27] >>True Checking (129) axxisLNatKind(tail(X28)) => axxu161(axxisLNatKind(X28)) (fun axxisLNatKind>axxu161) (fun axxisLNatKind=axxisLNatKind) subterm comparison of args w. Mul Mul (meta X28)[is acc in tail(X28)] [is positive in tail(X28)] [is acc in X28] >>True Checking (130) axxisLNatKind(take(Y28,U28)) => axxu171(axxisNaturalKind(Y28),U28) (fun axxisLNatKind=axxu171) subterm comparison of args w. Mul Mul >>False Found constructors: nil Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>OK Checking (408) map(%X.Z125[%X],nil) => nil (fun map>nil) >>True Checking (409) %Y.G125[%Y]@V125 => G125[V125] (meta G125)[is acc in %Y.G125[%Y],V125] [is acc in G125[%Y]] (meta V125)[is acc in %Y.G125[%Y],V125] [is acc in V125] >>True #SN! ******** Signature ******** 0 : A afterNth : (A,A) -> A app : ((A -> A),A) -> A axxafterNth : (A,A) -> A axxfst : A -> A axxhead : A -> A axxisLNat : A -> A axxisLNatKind : A -> A axxisNatural : A -> A axxisNaturalKind : A -> A axxisPLNat : A -> A axxisPLNatKind : A -> A axxnatsFrom : A -> A axxsel : (A,A) -> A axxsnd : A -> A axxsplitAt : (A,A) -> A axxtail : A -> A axxtake : (A,A) -> A axxu101 : (A,A,A) -> A axxu102 : (A,A,A) -> A axxu103 : (A,A,A) -> A axxu104 : (A,A,A) -> A axxu105 : (A,A) -> A axxu106 : A -> A axxu11 : (A,A,A) -> A axxu111 : (A,A) -> A axxu112 : A -> A axxu12 : (A,A,A) -> A axxu121 : (A,A) -> A axxu122 : A -> A axxu13 : (A,A,A) -> A axxu131 : A -> A axxu14 : (A,A,A) -> A axxu141 : A -> A axxu151 : A -> A axxu161 : A -> A axxu171 : (A,A) -> A axxu172 : A -> A axxu181 : (A,A) -> A axxu182 : (A,A) -> A axxu183 : A -> A axxu191 : (A,A) -> A axxu192 : (A,A) -> A axxu193 : A -> A axxu201 : (A,A,A) -> A axxu202 : (A,A,A) -> A axxu203 : (A,A,A) -> A axxu204 : (A,A,A) -> A axxu205 : (A,A) -> A axxu206 : A -> A axxu21 : (A,A,A) -> A axxu211 : A -> A axxu22 : (A,A,A) -> A axxu221 : A -> A axxu23 : (A,A,A) -> A axxu231 : (A,A) -> A axxu232 : A -> A axxu24 : (A,A) -> A axxu241 : (A,A,A) -> A axxu242 : (A,A,A) -> A axxu243 : (A,A,A) -> A axxu244 : (A,A,A) -> A axxu245 : (A,A) -> A axxu246 : A -> A axxu251 : (A,A,A) -> A axxu252 : (A,A,A) -> A axxu253 : (A,A,A) -> A axxu254 : (A,A,A) -> A axxu255 : (A,A) -> A axxu256 : A -> A axxu261 : (A,A) -> A axxu262 : A -> A axxu271 : (A,A) -> A axxu272 : A -> A axxu281 : (A,A) -> A axxu282 : (A,A) -> A axxu291 : (A,A,A) -> A axxu292 : (A,A,A) -> A axxu293 : (A,A,A) -> A axxu294 : (A,A,A) -> A axxu301 : (A,A,A) -> A axxu302 : (A,A) -> A axxu303 : (A,A) -> A axxu304 : (A,A) -> A axxu31 : (A,A,A) -> A axxu311 : (A,A) -> A axxu312 : (A,A) -> A axxu32 : (A,A,A) -> A axxu321 : (A,A,A,A) -> A axxu322 : (A,A,A,A) -> A axxu323 : (A,A,A,A) -> A axxu324 : (A,A,A,A) -> A axxu325 : (A,A,A,A) -> A axxu326 : (A,A,A,A) -> A axxu327 : (A,A) -> A axxu33 : (A,A,A) -> A axxu331 : (A,A,A) -> A axxu332 : (A,A) -> A axxu333 : (A,A) -> A axxu334 : (A,A) -> A axxu34 : (A,A) -> A axxu341 : (A,A,A) -> A axxu342 : (A,A,A) -> A axxu343 : (A,A,A) -> A axxu344 : (A,A,A) -> A axxu41 : (A,A,A) -> A axxu42 : (A,A,A) -> A axxu43 : (A,A,A) -> A axxu44 : (A,A,A) -> A axxu45 : (A,A) -> A axxu46 : A -> A axxu51 : (A,A,A) -> A axxu52 : (A,A,A) -> A axxu53 : (A,A,A) -> A axxu54 : (A,A,A) -> A axxu55 : (A,A) -> A axxu56 : A -> A axxu61 : (A,A) -> A axxu62 : (A,A) -> A axxu63 : A -> A axxu71 : (A,A) -> A axxu72 : (A,A) -> A axxu73 : A -> A axxu81 : (A,A) -> A axxu82 : (A,A) -> A axxu83 : A -> A axxu91 : (A,A) -> A axxu92 : (A,A) -> A axxu93 : A -> A cons : (A,A) -> A fst : A -> A head : A -> A isLNat : A -> A isLNatKind : A -> A isNatural : A -> A isNaturalKind : A -> A isPLNat : A -> A isPLNatKind : A -> A map : ((A -> A),A) -> A mark : A -> A natsFrom : A -> A nil : A pair : (A,A) -> A s : A -> A sel : (A,A) -> A snd : A -> A splitAt : (A,A) -> A tail : A -> A take : (A,A) -> A tt : A u101 : (A,A,A) -> A u102 : (A,A,A) -> A u103 : (A,A,A) -> A u104 : (A,A,A) -> A u105 : (A,A) -> A u106 : A -> A u11 : (A,A,A) -> A u111 : (A,A) -> A u112 : A -> A u12 : (A,A,A) -> A u121 : (A,A) -> A u122 : A -> A u13 : (A,A,A) -> A u131 : A -> A u14 : (A,A,A) -> A u141 : A -> A u151 : A -> A u161 : A -> A u171 : (A,A) -> A u172 : A -> A u181 : (A,A) -> A u182 : (A,A) -> A u183 : A -> A u191 : (A,A) -> A u192 : (A,A) -> A u193 : A -> A u201 : (A,A,A) -> A u202 : (A,A,A) -> A u203 : (A,A,A) -> A u204 : (A,A,A) -> A u205 : (A,A) -> A u206 : A -> A u21 : (A,A,A) -> A u211 : A -> A u22 : (A,A,A) -> A u221 : A -> A u23 : (A,A,A) -> A u231 : (A,A) -> A u232 : A -> A u24 : (A,A) -> A u241 : (A,A,A) -> A u242 : (A,A,A) -> A u243 : (A,A,A) -> A u244 : (A,A,A) -> A u245 : (A,A) -> A u246 : A -> A u251 : (A,A,A) -> A u252 : (A,A,A) -> A u253 : (A,A,A) -> A u254 : (A,A,A) -> A u255 : (A,A) -> A u256 : A -> A u261 : (A,A) -> A u262 : A -> A u271 : (A,A) -> A u272 : A -> A u281 : (A,A) -> A u282 : (A,A) -> A u291 : (A,A,A) -> A u292 : (A,A,A) -> A u293 : (A,A,A) -> A u294 : (A,A,A) -> A u301 : (A,A,A) -> A u302 : (A,A) -> A u303 : (A,A) -> A u304 : (A,A) -> A u31 : (A,A,A) -> A u311 : (A,A) -> A u312 : (A,A) -> A u32 : (A,A,A) -> A u321 : (A,A,A,A) -> A u322 : (A,A,A,A) -> A u323 : (A,A,A,A) -> A u324 : (A,A,A,A) -> A u325 : (A,A,A,A) -> A u326 : (A,A,A,A) -> A u327 : (A,A) -> A u33 : (A,A,A) -> A u331 : (A,A,A) -> A u332 : (A,A) -> A u333 : (A,A) -> A u334 : (A,A) -> A u34 : (A,A) -> A u341 : (A,A,A) -> A u342 : (A,A,A) -> A u343 : (A,A,A) -> A u344 : (A,A,A) -> A u41 : (A,A,A) -> A u42 : (A,A,A) -> A u43 : (A,A,A) -> A u44 : (A,A,A) -> A u45 : (A,A) -> A u46 : A -> A u51 : (A,A,A) -> A u52 : (A,A,A) -> A u53 : (A,A,A) -> A u54 : (A,A,A) -> A u55 : (A,A) -> A u56 : A -> A u61 : (A,A) -> A u62 : (A,A) -> A u63 : A -> A u71 : (A,A) -> A u72 : (A,A) -> A u73 : A -> A u81 : (A,A) -> A u82 : (A,A) -> A u83 : A -> A u91 : (A,A) -> A u92 : (A,A) -> A u93 : A -> A ******** Computation Rules ******** (1) axxu101(tt,X,Y) => axxu102(axxisNaturalKind(X),X,Y) (2) axxu102(tt,U,V) => axxu103(axxisLNatKind(V),U,V) (3) axxu103(tt,W,P) => axxu104(axxisLNatKind(P),W,P) (4) axxu104(tt,X1,Y1) => axxu105(axxisNatural(X1),Y1) (5) axxu105(tt,U1) => axxu106(axxisLNat(U1)) (6) axxu106(tt) => tt (7) axxu11(tt,V1,W1) => axxu12(axxisNaturalKind(V1),V1,W1) (8) axxu111(tt,P1) => axxu112(axxisLNatKind(P1)) (9) axxu112(tt) => tt (10) axxu12(tt,X2,Y2) => axxu13(axxisLNat(Y2),X2,Y2) (11) axxu121(tt,U2) => axxu122(axxisLNatKind(U2)) (12) axxu122(tt) => tt (13) axxu13(tt,V2,W2) => axxu14(axxisLNatKind(W2),V2,W2) (14) axxu131(tt) => tt (15) axxu14(tt,P2,X3) => axxsnd(axxsplitAt(mark(P2),mark(X3))) (16) axxu141(tt) => tt (17) axxu151(tt) => tt (18) axxu161(tt) => tt (19) axxu171(tt,Y3) => axxu172(axxisLNatKind(Y3)) (20) axxu172(tt) => tt (21) axxu181(tt,U3) => axxu182(axxisLNatKind(U3),U3) (22) axxu182(tt,V3) => axxu183(axxisLNat(V3)) (23) axxu183(tt) => tt (24) axxu191(tt,W3) => axxu192(axxisNaturalKind(W3),W3) (25) axxu192(tt,P3) => axxu193(axxisNatural(P3)) (26) axxu193(tt) => tt (27) axxu201(tt,X4,Y4) => axxu202(axxisNaturalKind(X4),X4,Y4) (28) axxu202(tt,U4,V4) => axxu203(axxisLNatKind(V4),U4,V4) (29) axxu203(tt,W4,P4) => axxu204(axxisLNatKind(P4),W4,P4) (30) axxu204(tt,X5,Y5) => axxu205(axxisNatural(X5),Y5) (31) axxu205(tt,U5) => axxu206(axxisLNat(U5)) (32) axxu206(tt) => tt (33) axxu21(tt,V5,W5) => axxu22(axxisLNatKind(V5),V5,W5) (34) axxu211(tt) => tt (35) axxu22(tt,P5,X6) => axxu23(axxisLNat(X6),P5,X6) (36) axxu221(tt) => tt (37) axxu23(tt,Y6,U6) => axxu24(axxisLNatKind(U6),Y6) (38) axxu231(tt,V6) => axxu232(axxisLNatKind(V6)) (39) axxu232(tt) => tt (40) axxu24(tt,W6) => mark(W6) (41) axxu241(tt,P6,X7) => axxu242(axxisLNatKind(P6),P6,X7) (42) axxu242(tt,Y7,U7) => axxu243(axxisLNatKind(U7),Y7,U7) (43) axxu243(tt,V7,W7) => axxu244(axxisLNatKind(W7),V7,W7) (44) axxu244(tt,P7,X8) => axxu245(axxisLNat(P7),X8) (45) axxu245(tt,Y8) => axxu246(axxisLNat(Y8)) (46) axxu246(tt) => tt (47) axxu251(tt,U8,V8) => axxu252(axxisNaturalKind(U8),U8,V8) (48) axxu252(tt,W8,P8) => axxu253(axxisLNatKind(P8),W8,P8) (49) axxu253(tt,X9,Y9) => axxu254(axxisLNatKind(Y9),X9,Y9) (50) axxu254(tt,U9,V9) => axxu255(axxisNatural(U9),V9) (51) axxu255(tt,W9) => axxu256(axxisLNat(W9)) (52) axxu256(tt) => tt (53) axxu261(tt,P9) => axxu262(axxisLNatKind(P9)) (54) axxu262(tt) => tt (55) axxu271(tt,X10) => axxu272(axxisLNatKind(X10)) (56) axxu272(tt) => tt (57) axxu281(tt,Y10) => axxu282(axxisNaturalKind(Y10),Y10) (58) axxu282(tt,U10) => cons(mark(U10),natsFrom(s(U10))) (59) axxu291(tt,V10,W10) => axxu292(axxisNaturalKind(V10),V10,W10) (60) axxu292(tt,P10,X11) => axxu293(axxisLNat(X11),P10,X11) (61) axxu293(tt,Y11,U11) => axxu294(axxisLNatKind(U11),Y11,U11) (62) axxu294(tt,V11,W11) => axxhead(axxafterNth(mark(V11),mark(W11))) (63) axxu301(tt,P11,X12) => axxu302(axxisLNatKind(P11),X12) (64) axxu302(tt,Y12) => axxu303(axxisLNat(Y12),Y12) (65) axxu303(tt,U12) => axxu304(axxisLNatKind(U12),U12) (66) axxu304(tt,V12) => mark(V12) (67) axxu31(tt,W12,P12) => axxu32(axxisNaturalKind(W12),W12,P12) (68) axxu311(tt,X13) => axxu312(axxisLNatKind(X13),X13) (69) axxu312(tt,Y13) => pair(nil,mark(Y13)) (70) axxu32(tt,U13,V13) => axxu33(axxisLNat(V13),U13,V13) (71) axxu321(tt,W13,P13,X14) => axxu322(axxisNaturalKind(W13),W13,P13,X14) (72) axxu322(tt,Y14,U14,V14) => axxu323(axxisNatural(U14),Y14,U14,V14) (73) axxu323(tt,W14,P14,X15) => axxu324(axxisNaturalKind(P14),W14,P14,X15) (74) axxu324(tt,Y15,U15,V15) => axxu325(axxisLNat(V15),Y15,U15,V15) (75) axxu325(tt,W15,P15,X16) => axxu326(axxisLNatKind(X16),W15,P15,X16) (76) axxu326(tt,Y16,U16,V16) => axxu327(axxsplitAt(mark(Y16),mark(V16)),U16) (77) axxu327(pair(W16,P16),X17) => pair(cons(mark(X17),W16),mark(P16)) (78) axxu33(tt,Y17,U17) => axxu34(axxisLNatKind(U17),Y17) (79) axxu331(tt,V17,W17) => axxu332(axxisNaturalKind(V17),W17) (80) axxu332(tt,P17) => axxu333(axxisLNat(P17),P17) (81) axxu333(tt,X18) => axxu334(axxisLNatKind(X18),X18) (82) axxu334(tt,Y18) => mark(Y18) (83) axxu34(tt,U18) => mark(U18) (84) axxu341(tt,V18,W18) => axxu342(axxisNaturalKind(V18),V18,W18) (85) axxu342(tt,P18,X19) => axxu343(axxisLNat(X19),P18,X19) (86) axxu343(tt,Y19,U19) => axxu344(axxisLNatKind(U19),Y19,U19) (87) axxu344(tt,V19,W19) => axxfst(axxsplitAt(mark(V19),mark(W19))) (88) axxu41(tt,P19,X20) => axxu42(axxisNaturalKind(P19),P19,X20) (89) axxu42(tt,Y20,U20) => axxu43(axxisLNatKind(U20),Y20,U20) (90) axxu43(tt,V20,W20) => axxu44(axxisLNatKind(W20),V20,W20) (91) axxu44(tt,P20,X21) => axxu45(axxisNatural(P20),X21) (92) axxu45(tt,Y21) => axxu46(axxisLNat(Y21)) (93) axxu46(tt) => tt (94) axxu51(tt,U21,V21) => axxu52(axxisNaturalKind(U21),U21,V21) (95) axxu52(tt,W21,P21) => axxu53(axxisLNatKind(P21),W21,P21) (96) axxu53(tt,X22,Y22) => axxu54(axxisLNatKind(Y22),X22,Y22) (97) axxu54(tt,U22,V22) => axxu55(axxisNatural(U22),V22) (98) axxu55(tt,W22) => axxu56(axxisLNat(W22)) (99) axxu56(tt) => tt (100) axxu61(tt,P22) => axxu62(axxisPLNatKind(P22),P22) (101) axxu62(tt,X23) => axxu63(axxisPLNat(X23)) (102) axxu63(tt) => tt (103) axxu71(tt,Y23) => axxu72(axxisNaturalKind(Y23),Y23) (104) axxu72(tt,U23) => axxu73(axxisNatural(U23)) (105) axxu73(tt) => tt (106) axxu81(tt,V23) => axxu82(axxisPLNatKind(V23),V23) (107) axxu82(tt,W23) => axxu83(axxisPLNat(W23)) (108) axxu83(tt) => tt (109) axxu91(tt,P23) => axxu92(axxisLNatKind(P23),P23) (110) axxu92(tt,X24) => axxu93(axxisLNat(X24)) (111) axxu93(tt) => tt (112) axxafterNth(Y24,U24) => axxu11(axxisNatural(Y24),Y24,U24) (113) axxfst(pair(V24,W24)) => axxu21(axxisLNat(V24),V24,W24) (114) axxhead(cons(P24,X25)) => axxu31(axxisNatural(P24),P24,X25) (115) axxisLNat(nil) => tt (116) axxisLNat(afterNth(Y25,U25)) => axxu41(axxisNaturalKind(Y25),Y25,U25) (117) axxisLNat(cons(V25,W25)) => axxu51(axxisNaturalKind(V25),V25,W25) (118) axxisLNat(fst(P25)) => axxu61(axxisPLNatKind(P25),P25) (119) axxisLNat(natsFrom(X26)) => axxu71(axxisNaturalKind(X26),X26) (120) axxisLNat(snd(Y26)) => axxu81(axxisPLNatKind(Y26),Y26) (121) axxisLNat(tail(U26)) => axxu91(axxisLNatKind(U26),U26) (122) axxisLNat(take(V26,W26)) => axxu101(axxisNaturalKind(V26),V26,W26) (123) axxisLNatKind(nil) => tt (124) axxisLNatKind(afterNth(P26,X27)) => axxu111(axxisNaturalKind(P26),X27) (125) axxisLNatKind(cons(Y27,U27)) => axxu121(axxisNaturalKind(Y27),U27) (126) axxisLNatKind(fst(V27)) => axxu131(axxisPLNatKind(V27)) (127) axxisLNatKind(natsFrom(W27)) => axxu141(axxisNaturalKind(W27)) (128) axxisLNatKind(snd(P27)) => axxu151(axxisPLNatKind(P27)) (129) axxisLNatKind(tail(X28)) => axxu161(axxisLNatKind(X28)) (130) axxisLNatKind(take(Y28,U28)) => axxu171(axxisNaturalKind(Y28),U28) (131) axxisNatural(0) => tt (132) axxisNatural(head(V28)) => axxu181(axxisLNatKind(V28),V28) (133) axxisNatural(s(W28)) => axxu191(axxisNaturalKind(W28),W28) (134) axxisNatural(sel(P28,X29)) => axxu201(axxisNaturalKind(P28),P28,X29) (135) axxisNaturalKind(0) => tt (136) axxisNaturalKind(head(Y29)) => axxu211(axxisLNatKind(Y29)) (137) axxisNaturalKind(s(U29)) => axxu221(axxisNaturalKind(U29)) (138) axxisNaturalKind(sel(V29,W29)) => axxu231(axxisNaturalKind(V29),W29) (139) axxisPLNat(pair(P29,X30)) => axxu241(axxisLNatKind(P29),P29,X30) (140) axxisPLNat(splitAt(Y30,U30)) => axxu251(axxisNaturalKind(Y30),Y30,U30) (141) axxisPLNatKind(pair(V30,W30)) => axxu261(axxisLNatKind(V30),W30) (142) axxisPLNatKind(splitAt(P30,X31)) => axxu271(axxisNaturalKind(P30),X31) (143) axxnatsFrom(Y31) => axxu281(axxisNatural(Y31),Y31) (144) axxsel(U31,V31) => axxu291(axxisNatural(U31),U31,V31) (145) axxsnd(pair(W31,P31)) => axxu301(axxisLNat(W31),W31,P31) (146) axxsplitAt(0,X32) => axxu311(axxisLNat(X32),X32) (147) axxsplitAt(s(Y32),cons(U32,V32)) => axxu321(axxisNatural(Y32),Y32,U32,V32) (148) axxtail(cons(W32,P32)) => axxu331(axxisNatural(W32),W32,P32) (149) axxtake(X33,Y33) => axxu341(axxisNatural(X33),X33,Y33) (150) mark(u101(U33,V33,W33)) => axxu101(mark(U33),V33,W33) (151) mark(u102(P33,X34,Y34)) => axxu102(mark(P33),X34,Y34) (152) mark(isNaturalKind(U34)) => axxisNaturalKind(U34) (153) mark(u103(V34,W34,P34)) => axxu103(mark(V34),W34,P34) (154) mark(isLNatKind(X35)) => axxisLNatKind(X35) (155) mark(u104(Y35,U35,V35)) => axxu104(mark(Y35),U35,V35) (156) mark(u105(W35,P35)) => axxu105(mark(W35),P35) (157) mark(isNatural(X36)) => axxisNatural(X36) (158) mark(u106(Y36)) => axxu106(mark(Y36)) (159) mark(isLNat(U36)) => axxisLNat(U36) (160) mark(u11(V36,W36,P36)) => axxu11(mark(V36),W36,P36) (161) mark(u12(X37,Y37,U37)) => axxu12(mark(X37),Y37,U37) (162) mark(u111(V37,W37)) => axxu111(mark(V37),W37) (163) mark(u112(P37)) => axxu112(mark(P37)) (164) mark(u13(X38,Y38,U38)) => axxu13(mark(X38),Y38,U38) (165) mark(u121(V38,W38)) => axxu121(mark(V38),W38) (166) mark(u122(P38)) => axxu122(mark(P38)) (167) mark(u14(X39,Y39,U39)) => axxu14(mark(X39),Y39,U39) (168) mark(u131(V39)) => axxu131(mark(V39)) (169) mark(snd(W39)) => axxsnd(mark(W39)) (170) mark(splitAt(P39,X40)) => axxsplitAt(mark(P39),mark(X40)) (171) mark(u141(Y40)) => axxu141(mark(Y40)) (172) mark(u151(U40)) => axxu151(mark(U40)) (173) mark(u161(V40)) => axxu161(mark(V40)) (174) mark(u171(W40,P40)) => axxu171(mark(W40),P40) (175) mark(u172(X41)) => axxu172(mark(X41)) (176) mark(u181(Y41,U41)) => axxu181(mark(Y41),U41) (177) mark(u182(V41,W41)) => axxu182(mark(V41),W41) (178) mark(u183(P41)) => axxu183(mark(P41)) (179) mark(u191(X42,Y42)) => axxu191(mark(X42),Y42) (180) mark(u192(U42,V42)) => axxu192(mark(U42),V42) (181) mark(u193(W42)) => axxu193(mark(W42)) (182) mark(u201(P42,X43,Y43)) => axxu201(mark(P42),X43,Y43) (183) mark(u202(U43,V43,W43)) => axxu202(mark(U43),V43,W43) (184) mark(u203(P43,X44,Y44)) => axxu203(mark(P43),X44,Y44) (185) mark(u204(U44,V44,W44)) => axxu204(mark(U44),V44,W44) (186) mark(u205(P44,X45)) => axxu205(mark(P44),X45) (187) mark(u206(Y45)) => axxu206(mark(Y45)) (188) mark(u21(U45,V45,W45)) => axxu21(mark(U45),V45,W45) (189) mark(u22(P45,X46,Y46)) => axxu22(mark(P45),X46,Y46) (190) mark(u211(U46)) => axxu211(mark(U46)) (191) mark(u23(V46,W46,P46)) => axxu23(mark(V46),W46,P46) (192) mark(u221(X47)) => axxu221(mark(X47)) (193) mark(u24(Y47,U47)) => axxu24(mark(Y47),U47) (194) mark(u231(V47,W47)) => axxu231(mark(V47),W47) (195) mark(u232(P47)) => axxu232(mark(P47)) (196) mark(u241(X48,Y48,U48)) => axxu241(mark(X48),Y48,U48) (197) mark(u242(V48,W48,P48)) => axxu242(mark(V48),W48,P48) (198) mark(u243(X49,Y49,U49)) => axxu243(mark(X49),Y49,U49) (199) mark(u244(V49,W49,P49)) => axxu244(mark(V49),W49,P49) (200) mark(u245(X50,Y50)) => axxu245(mark(X50),Y50) (201) mark(u246(U50)) => axxu246(mark(U50)) (202) mark(u251(V50,W50,P50)) => axxu251(mark(V50),W50,P50) (203) mark(u252(X51,Y51,U51)) => axxu252(mark(X51),Y51,U51) (204) mark(u253(V51,W51,P51)) => axxu253(mark(V51),W51,P51) (205) mark(u254(X52,Y52,U52)) => axxu254(mark(X52),Y52,U52) (206) mark(u255(V52,W52)) => axxu255(mark(V52),W52) (207) mark(u256(P52)) => axxu256(mark(P52)) (208) mark(u261(X53,Y53)) => axxu261(mark(X53),Y53) (209) mark(u262(U53)) => axxu262(mark(U53)) (210) mark(u271(V53,W53)) => axxu271(mark(V53),W53) (211) mark(u272(P53)) => axxu272(mark(P53)) (212) mark(u281(X54,Y54)) => axxu281(mark(X54),Y54) (213) mark(u282(U54,V54)) => axxu282(mark(U54),V54) (214) mark(natsFrom(W54)) => axxnatsFrom(mark(W54)) (215) mark(u291(P54,X55,Y55)) => axxu291(mark(P54),X55,Y55) (216) mark(u292(U55,V55,W55)) => axxu292(mark(U55),V55,W55) (217) mark(u293(P55,X56,Y56)) => axxu293(mark(P55),X56,Y56) (218) mark(u294(U56,V56,W56)) => axxu294(mark(U56),V56,W56) (219) mark(head(P56)) => axxhead(mark(P56)) (220) mark(afterNth(X57,Y57)) => axxafterNth(mark(X57),mark(Y57)) (221) mark(u301(U57,V57,W57)) => axxu301(mark(U57),V57,W57) (222) mark(u302(P57,X58)) => axxu302(mark(P57),X58) (223) mark(u303(Y58,U58)) => axxu303(mark(Y58),U58) (224) mark(u304(V58,W58)) => axxu304(mark(V58),W58) (225) mark(u31(P58,X59,Y59)) => axxu31(mark(P58),X59,Y59) (226) mark(u32(U59,V59,W59)) => axxu32(mark(U59),V59,W59) (227) mark(u311(P59,X60)) => axxu311(mark(P59),X60) (228) mark(u312(Y60,U60)) => axxu312(mark(Y60),U60) (229) mark(u33(V60,W60,P60)) => axxu33(mark(V60),W60,P60) (230) mark(u321(X61,Y61,U61,V61)) => axxu321(mark(X61),Y61,U61,V61) (231) mark(u322(W61,P61,X62,Y62)) => axxu322(mark(W61),P61,X62,Y62) (232) mark(u323(U62,V62,W62,P62)) => axxu323(mark(U62),V62,W62,P62) (233) mark(u324(X63,Y63,U63,V63)) => axxu324(mark(X63),Y63,U63,V63) (234) mark(u325(W63,P63,X64,Y64)) => axxu325(mark(W63),P63,X64,Y64) (235) mark(u326(U64,V64,W64,P64)) => axxu326(mark(U64),V64,W64,P64) (236) mark(u327(X65,Y65)) => axxu327(mark(X65),Y65) (237) mark(u34(U65,V65)) => axxu34(mark(U65),V65) (238) mark(u331(W65,P65,X66)) => axxu331(mark(W65),P65,X66) (239) mark(u332(Y66,U66)) => axxu332(mark(Y66),U66) (240) mark(u333(V66,W66)) => axxu333(mark(V66),W66) (241) mark(u334(P66,X67)) => axxu334(mark(P66),X67) (242) mark(u341(Y67,U67,V67)) => axxu341(mark(Y67),U67,V67) (243) mark(u342(W67,P67,X68)) => axxu342(mark(W67),P67,X68) (244) mark(u343(Y68,U68,V68)) => axxu343(mark(Y68),U68,V68) (245) mark(u344(W68,P68,X69)) => axxu344(mark(W68),P68,X69) (246) mark(fst(Y69)) => axxfst(mark(Y69)) (247) mark(u41(U69,V69,W69)) => axxu41(mark(U69),V69,W69) (248) mark(u42(P69,X70,Y70)) => axxu42(mark(P69),X70,Y70) (249) mark(u43(U70,V70,W70)) => axxu43(mark(U70),V70,W70) (250) mark(u44(P70,X71,Y71)) => axxu44(mark(P70),X71,Y71) (251) mark(u45(U71,V71)) => axxu45(mark(U71),V71) (252) mark(u46(W71)) => axxu46(mark(W71)) (253) mark(u51(P71,X72,Y72)) => axxu51(mark(P71),X72,Y72) (254) mark(u52(U72,V72,W72)) => axxu52(mark(U72),V72,W72) (255) mark(u53(P72,X73,Y73)) => axxu53(mark(P72),X73,Y73) (256) mark(u54(U73,V73,W73)) => axxu54(mark(U73),V73,W73) (257) mark(u55(P73,X74)) => axxu55(mark(P73),X74) (258) mark(u56(Y74)) => axxu56(mark(Y74)) (259) mark(u61(U74,V74)) => axxu61(mark(U74),V74) (260) mark(u62(W74,P74)) => axxu62(mark(W74),P74) (261) mark(isPLNatKind(X75)) => axxisPLNatKind(X75) (262) mark(u63(Y75)) => axxu63(mark(Y75)) (263) mark(isPLNat(U75)) => axxisPLNat(U75) (264) mark(u71(V75,W75)) => axxu71(mark(V75),W75) (265) mark(u72(P75,X76)) => axxu72(mark(P75),X76) (266) mark(u73(Y76)) => axxu73(mark(Y76)) (267) mark(u81(U76,V76)) => axxu81(mark(U76),V76) (268) mark(u82(W76,P76)) => axxu82(mark(W76),P76) (269) mark(u83(X77)) => axxu83(mark(X77)) (270) mark(u91(Y77,U77)) => axxu91(mark(Y77),U77) (271) mark(u92(V77,W77)) => axxu92(mark(V77),W77) (272) mark(u93(P77)) => axxu93(mark(P77)) (273) mark(tail(X78)) => axxtail(mark(X78)) (274) mark(take(Y78,U78)) => axxtake(mark(Y78),mark(U78)) (275) mark(sel(V78,W78)) => axxsel(mark(V78),mark(W78)) (276) mark(tt) => tt (277) mark(cons(P78,X79)) => cons(mark(P78),X79) (278) mark(s(Y79)) => s(mark(Y79)) (279) mark(pair(U79,V79)) => pair(mark(U79),mark(V79)) (280) mark(nil) => nil (281) mark(0) => 0 (282) axxu101(W79,P79,X80) => u101(W79,P79,X80) (283) axxu102(Y80,U80,V80) => u102(Y80,U80,V80) (284) axxisNaturalKind(W80) => isNaturalKind(W80) (285) axxu103(P80,X81,Y81) => u103(P80,X81,Y81) (286) axxisLNatKind(U81) => isLNatKind(U81) (287) axxu104(V81,W81,P81) => u104(V81,W81,P81) (288) axxu105(X82,Y82) => u105(X82,Y82) (289) axxisNatural(U82) => isNatural(U82) (290) axxu106(V82) => u106(V82) (291) axxisLNat(W82) => isLNat(W82) (292) axxu11(P82,X83,Y83) => u11(P82,X83,Y83) (293) axxu12(U83,V83,W83) => u12(U83,V83,W83) (294) axxu111(P83,X84) => u111(P83,X84) (295) axxu112(Y84) => u112(Y84) (296) axxu13(U84,V84,W84) => u13(U84,V84,W84) (297) axxu121(P84,X85) => u121(P84,X85) (298) axxu122(Y85) => u122(Y85) (299) axxu14(U85,V85,W85) => u14(U85,V85,W85) (300) axxu131(P85) => u131(P85) (301) axxsnd(X86) => snd(X86) (302) axxsplitAt(Y86,U86) => splitAt(Y86,U86) (303) axxu141(V86) => u141(V86) (304) axxu151(W86) => u151(W86) (305) axxu161(P86) => u161(P86) (306) axxu171(X87,Y87) => u171(X87,Y87) (307) axxu172(U87) => u172(U87) (308) axxu181(V87,W87) => u181(V87,W87) (309) axxu182(P87,X88) => u182(P87,X88) (310) axxu183(Y88) => u183(Y88) (311) axxu191(U88,V88) => u191(U88,V88) (312) axxu192(W88,P88) => u192(W88,P88) (313) axxu193(X89) => u193(X89) (314) axxu201(Y89,U89,V89) => u201(Y89,U89,V89) (315) axxu202(W89,P89,X90) => u202(W89,P89,X90) (316) axxu203(Y90,U90,V90) => u203(Y90,U90,V90) (317) axxu204(W90,P90,X91) => u204(W90,P90,X91) (318) axxu205(Y91,U91) => u205(Y91,U91) (319) axxu206(V91) => u206(V91) (320) axxu21(W91,P91,X92) => u21(W91,P91,X92) (321) axxu22(Y92,U92,V92) => u22(Y92,U92,V92) (322) axxu211(W92) => u211(W92) (323) axxu23(P92,X93,Y93) => u23(P92,X93,Y93) (324) axxu221(U93) => u221(U93) (325) axxu24(V93,W93) => u24(V93,W93) (326) axxu231(P93,X94) => u231(P93,X94) (327) axxu232(Y94) => u232(Y94) (328) axxu241(U94,V94,W94) => u241(U94,V94,W94) (329) axxu242(P94,X95,Y95) => u242(P94,X95,Y95) (330) axxu243(U95,V95,W95) => u243(U95,V95,W95) (331) axxu244(P95,X96,Y96) => u244(P95,X96,Y96) (332) axxu245(U96,V96) => u245(U96,V96) (333) axxu246(W96) => u246(W96) (334) axxu251(P96,X97,Y97) => u251(P96,X97,Y97) (335) axxu252(U97,V97,W97) => u252(U97,V97,W97) (336) axxu253(P97,X98,Y98) => u253(P97,X98,Y98) (337) axxu254(U98,V98,W98) => u254(U98,V98,W98) (338) axxu255(P98,X99) => u255(P98,X99) (339) axxu256(Y99) => u256(Y99) (340) axxu261(U99,V99) => u261(U99,V99) (341) axxu262(W99) => u262(W99) (342) axxu271(P99,X100) => u271(P99,X100) (343) axxu272(Y100) => u272(Y100) (344) axxu281(U100,V100) => u281(U100,V100) (345) axxu282(W100,P100) => u282(W100,P100) (346) axxnatsFrom(X101) => natsFrom(X101) (347) axxu291(Y101,U101,V101) => u291(Y101,U101,V101) (348) axxu292(W101,P101,X102) => u292(W101,P101,X102) (349) axxu293(Y102,U102,V102) => u293(Y102,U102,V102) (350) axxu294(W102,P102,X103) => u294(W102,P102,X103) (351) axxhead(Y103) => head(Y103) (352) axxafterNth(U103,V103) => afterNth(U103,V103) (353) axxu301(W103,P103,X104) => u301(W103,P103,X104) (354) axxu302(Y104,U104) => u302(Y104,U104) (355) axxu303(V104,W104) => u303(V104,W104) (356) axxu304(P104,X105) => u304(P104,X105) (357) axxu31(Y105,U105,V105) => u31(Y105,U105,V105) (358) axxu32(W105,P105,X106) => u32(W105,P105,X106) (359) axxu311(Y106,U106) => u311(Y106,U106) (360) axxu312(V106,W106) => u312(V106,W106) (361) axxu33(P106,X107,Y107) => u33(P106,X107,Y107) (362) axxu321(U107,V107,W107,P107) => u321(U107,V107,W107,P107) (363) axxu322(X108,Y108,U108,V108) => u322(X108,Y108,U108,V108) (364) axxu323(W108,P108,X109,Y109) => u323(W108,P108,X109,Y109) (365) axxu324(U109,V109,W109,P109) => u324(U109,V109,W109,P109) (366) axxu325(X110,Y110,U110,V110) => u325(X110,Y110,U110,V110) (367) axxu326(W110,P110,X111,Y111) => u326(W110,P110,X111,Y111) (368) axxu327(U111,V111) => u327(U111,V111) (369) axxu34(W111,P111) => u34(W111,P111) (370) axxu331(X112,Y112,U112) => u331(X112,Y112,U112) (371) axxu332(V112,W112) => u332(V112,W112) (372) axxu333(P112,X113) => u333(P112,X113) (373) axxu334(Y113,U113) => u334(Y113,U113) (374) axxu341(V113,W113,P113) => u341(V113,W113,P113) (375) axxu342(X114,Y114,U114) => u342(X114,Y114,U114) (376) axxu343(V114,W114,P114) => u343(V114,W114,P114) (377) axxu344(X115,Y115,U115) => u344(X115,Y115,U115) (378) axxfst(V115) => fst(V115) (379) axxu41(W115,P115,X116) => u41(W115,P115,X116) (380) axxu42(Y116,U116,V116) => u42(Y116,U116,V116) (381) axxu43(W116,P116,X117) => u43(W116,P116,X117) (382) axxu44(Y117,U117,V117) => u44(Y117,U117,V117) (383) axxu45(W117,P117) => u45(W117,P117) (384) axxu46(X118) => u46(X118) (385) axxu51(Y118,U118,V118) => u51(Y118,U118,V118) (386) axxu52(W118,P118,X119) => u52(W118,P118,X119) (387) axxu53(Y119,U119,V119) => u53(Y119,U119,V119) (388) axxu54(W119,P119,X120) => u54(W119,P119,X120) (389) axxu55(Y120,U120) => u55(Y120,U120) (390) axxu56(V120) => u56(V120) (391) axxu61(W120,P120) => u61(W120,P120) (392) axxu62(X121,Y121) => u62(X121,Y121) (393) axxisPLNatKind(U121) => isPLNatKind(U121) (394) axxu63(V121) => u63(V121) (395) axxisPLNat(W121) => isPLNat(W121) (396) axxu71(P121,X122) => u71(P121,X122) (397) axxu72(Y122,U122) => u72(Y122,U122) (398) axxu73(V122) => u73(V122) (399) axxu81(W122,P122) => u81(W122,P122) (400) axxu82(X123,Y123) => u82(X123,Y123) (401) axxu83(U123) => u83(U123) (402) axxu91(V123,W123) => u91(V123,W123) (403) axxu92(P123,X124) => u92(P123,X124) (404) axxu93(Y124) => u93(Y124) (405) axxtail(U124) => tail(U124) (406) axxtake(V124,W124) => take(V124,W124) (407) axxsel(P124,X125) => sel(P124,X125) (408) map(%X.Z125[%X],nil) => nil (409) %Y.G125[%Y]@V125 => G125[V125] YES