MAYBE Time: 1.644196 TRS: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} DP: DP: { mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2), mark# cons(X1, X2) -> active# cons(mark X1, X2), mark# natsFrom X -> mark# X, mark# natsFrom X -> natsFrom# mark X, mark# natsFrom X -> active# natsFrom mark X, mark# s X -> mark# X, mark# s X -> s# mark X, mark# s X -> active# s mark X, mark# fst X -> mark# X, mark# fst X -> active# fst mark X, mark# fst X -> fst# mark X, mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2), mark# pair(X1, X2) -> pair#(mark X1, mark X2), mark# snd X -> mark# X, mark# snd X -> active# snd mark X, mark# snd X -> snd# mark X, mark# nil() -> active# nil(), mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), mark# 0() -> active# 0(), mark# u(X1, X2, X3, X4) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), mark# head X -> mark# X, mark# head X -> active# head mark X, mark# head X -> head# mark X, mark# tail X -> mark# X, mark# tail X -> active# tail mark X, mark# tail X -> tail# mark X, mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2), mark# sel(X1, X2) -> sel#(mark X1, mark X2), mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2), mark# take(X1, X2) -> take#(mark X1, mark X2), cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2), natsFrom# mark X -> natsFrom# X, natsFrom# active X -> natsFrom# X, s# mark X -> s# X, s# active X -> s# X, active# natsFrom N -> mark# cons(N, natsFrom s N), active# natsFrom N -> cons#(N, natsFrom s N), active# natsFrom N -> natsFrom# s N, active# natsFrom N -> s# N, active# fst pair(XS, YS) -> mark# XS, active# snd pair(XS, YS) -> mark# YS, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), active# splitAt(0(), XS) -> mark# pair(nil(), XS), active# splitAt(0(), XS) -> pair#(nil(), XS), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS), active# head cons(N, XS) -> mark# N, active# tail cons(N, XS) -> mark# XS, active# afterNth(N, XS) -> mark# snd splitAt(N, XS), active# afterNth(N, XS) -> snd# splitAt(N, XS), active# afterNth(N, XS) -> splitAt#(N, XS), active# sel(N, XS) -> mark# head afterNth(N, XS), active# sel(N, XS) -> head# afterNth(N, XS), active# sel(N, XS) -> afterNth#(N, XS), active# take(N, XS) -> mark# fst splitAt(N, XS), active# take(N, XS) -> fst# splitAt(N, XS), active# take(N, XS) -> splitAt#(N, XS), fst# mark X -> fst# X, fst# active X -> fst# X, pair#(X1, mark X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2), snd# mark X -> snd# X, snd# active X -> snd# X, splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), head# mark X -> head# X, head# active X -> head# X, tail# mark X -> tail# X, tail# active X -> tail# X, afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2), take#(X1, mark X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)} TRS: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} UR: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} EDG: { (mark# 0() -> active# 0(), active# take(N, XS) -> splitAt#(N, XS)) (mark# 0() -> active# 0(), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# 0() -> active# 0(), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# 0() -> active# 0(), active# sel(N, XS) -> afterNth#(N, XS)) (mark# 0() -> active# 0(), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# 0() -> active# 0(), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# 0() -> active# 0(), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# 0() -> active# 0(), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# 0() -> active# 0(), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# 0() -> active# 0(), active# tail cons(N, XS) -> mark# XS) (mark# 0() -> active# 0(), active# head cons(N, XS) -> mark# N) (mark# 0() -> active# 0(), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# 0() -> active# 0(), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# 0() -> active# 0(), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# 0() -> active# 0(), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# 0() -> active# 0(), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# 0() -> active# 0(), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# 0() -> active# 0(), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# 0() -> active# 0(), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# 0() -> active# 0(), active# snd pair(XS, YS) -> mark# YS) (mark# 0() -> active# 0(), active# fst pair(XS, YS) -> mark# XS) (mark# 0() -> active# 0(), active# natsFrom N -> s# N) (mark# 0() -> active# 0(), active# natsFrom N -> natsFrom# s N) (mark# 0() -> active# 0(), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# 0() -> active# 0(), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# s X -> s# mark X, s# active X -> s# X) (mark# s X -> s# mark X, s# mark X -> s# X) (mark# snd X -> snd# mark X, snd# active X -> snd# X) (mark# snd X -> snd# mark X, snd# mark X -> snd# X) (mark# tail X -> tail# mark X, tail# active X -> tail# X) (mark# tail X -> tail# mark X, tail# mark X -> tail# X) (active# natsFrom N -> natsFrom# s N, natsFrom# active X -> natsFrom# X) (active# natsFrom N -> natsFrom# s N, natsFrom# mark X -> natsFrom# X) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (cons#(X1, active X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2)) (cons#(X1, active X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (cons#(X1, active X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2)) (cons#(X1, active X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (cons#(active X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2)) (cons#(active X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2)) (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (pair#(X1, active X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)) (pair#(X1, active X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2)) (pair#(X1, active X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2)) (pair#(X1, active X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2)) (pair#(active X1, X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)) (pair#(active X1, X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2)) (pair#(active X1, X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2)) (pair#(active X1, X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2)) (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)) (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2)) (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2)) (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2)) (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)) (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2)) (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2)) (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2)) (sel#(X1, active X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2)) (sel#(X1, active X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2)) (sel#(X1, active X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2)) (sel#(X1, active X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2)) (sel#(active X1, X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2)) (sel#(active X1, X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2)) (sel#(active X1, X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2)) (sel#(active X1, X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2)) (take#(X1, active X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)) (take#(X1, active X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2)) (take#(X1, active X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2)) (take#(X1, active X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (take#(active X1, X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)) (take#(active X1, X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2)) (take#(active X1, X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2)) (take#(active X1, X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (active# natsFrom N -> cons#(N, natsFrom s N), cons#(active X1, X2) -> cons#(X1, X2)) (active# natsFrom N -> cons#(N, natsFrom s N), cons#(mark X1, X2) -> cons#(X1, X2)) (active# natsFrom N -> cons#(N, natsFrom s N), cons#(X1, active X2) -> cons#(X1, X2)) (active# natsFrom N -> cons#(N, natsFrom s N), cons#(X1, mark X2) -> cons#(X1, X2)) (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(active X1, X2) -> sel#(X1, X2)) (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(mark X1, X2) -> sel#(X1, X2)) (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(X1, active X2) -> sel#(X1, X2)) (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(X1, mark X2) -> sel#(X1, X2)) (active# natsFrom N -> s# N, s# active X -> s# X) (active# natsFrom N -> s# N, s# mark X -> s# X) (active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS), cons#(active X1, X2) -> cons#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS), cons#(mark X1, X2) -> cons#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS), cons#(X1, active X2) -> cons#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS), cons#(X1, mark X2) -> cons#(X1, X2)) (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> mark# X2) (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> mark# X1) (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> mark# X2) (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> mark# X1) (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> mark# X2) (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> mark# X1) (active# tail cons(N, XS) -> mark# XS, mark# tail X -> tail# mark X) (active# tail cons(N, XS) -> mark# XS, mark# tail X -> active# tail mark X) (active# tail cons(N, XS) -> mark# XS, mark# tail X -> mark# X) (active# tail cons(N, XS) -> mark# XS, mark# head X -> head# mark X) (active# tail cons(N, XS) -> mark# XS, mark# head X -> active# head mark X) (active# tail cons(N, XS) -> mark# XS, mark# head X -> mark# X) (active# tail cons(N, XS) -> mark# XS, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# tail cons(N, XS) -> mark# XS, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# tail cons(N, XS) -> mark# XS, mark# u(X1, X2, X3, X4) -> mark# X1) (active# tail cons(N, XS) -> mark# XS, mark# 0() -> active# 0()) (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> mark# X2) (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> mark# X1) (active# tail cons(N, XS) -> mark# XS, mark# nil() -> active# nil()) (active# tail cons(N, XS) -> mark# XS, mark# snd X -> snd# mark X) (active# tail cons(N, XS) -> mark# XS, mark# snd X -> active# snd mark X) (active# tail cons(N, XS) -> mark# XS, mark# snd X -> mark# X) (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> mark# X2) (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> mark# X1) (active# tail cons(N, XS) -> mark# XS, mark# fst X -> fst# mark X) (active# tail cons(N, XS) -> mark# XS, mark# fst X -> active# fst mark X) (active# tail cons(N, XS) -> mark# XS, mark# fst X -> mark# X) (active# tail cons(N, XS) -> mark# XS, mark# s X -> active# s mark X) (active# tail cons(N, XS) -> mark# XS, mark# s X -> s# mark X) (active# tail cons(N, XS) -> mark# XS, mark# s X -> mark# X) (active# tail cons(N, XS) -> mark# XS, mark# natsFrom X -> active# natsFrom mark X) (active# tail cons(N, XS) -> mark# XS, mark# natsFrom X -> natsFrom# mark X) (active# tail cons(N, XS) -> mark# XS, mark# natsFrom X -> mark# X) (active# tail cons(N, XS) -> mark# XS, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# tail cons(N, XS) -> mark# XS, mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# tail cons(N, XS) -> mark# XS, mark# cons(X1, X2) -> mark# X1) (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> mark# X2) (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> mark# X2) (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> mark# X1) (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> mark# X2) (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> mark# X1) (mark# natsFrom X -> mark# X, mark# tail X -> tail# mark X) (mark# natsFrom X -> mark# X, mark# tail X -> active# tail mark X) (mark# natsFrom X -> mark# X, mark# tail X -> mark# X) (mark# natsFrom X -> mark# X, mark# head X -> head# mark X) (mark# natsFrom X -> mark# X, mark# head X -> active# head mark X) (mark# natsFrom X -> mark# X, mark# head X -> mark# X) (mark# natsFrom X -> mark# X, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# natsFrom X -> mark# X, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# natsFrom X -> mark# X, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# natsFrom X -> mark# X, mark# 0() -> active# 0()) (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> mark# X2) (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> mark# X1) (mark# natsFrom X -> mark# X, mark# nil() -> active# nil()) (mark# natsFrom X -> mark# X, mark# snd X -> snd# mark X) (mark# natsFrom X -> mark# X, mark# snd X -> active# snd mark X) (mark# natsFrom X -> mark# X, mark# snd X -> mark# X) (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> mark# X2) (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# natsFrom X -> mark# X, mark# fst X -> fst# mark X) (mark# natsFrom X -> mark# X, mark# fst X -> active# fst mark X) (mark# natsFrom X -> mark# X, mark# fst X -> mark# X) (mark# natsFrom X -> mark# X, mark# s X -> active# s mark X) (mark# natsFrom X -> mark# X, mark# s X -> s# mark X) (mark# natsFrom X -> mark# X, mark# s X -> mark# X) (mark# natsFrom X -> mark# X, mark# natsFrom X -> active# natsFrom mark X) (mark# natsFrom X -> mark# X, mark# natsFrom X -> natsFrom# mark X) (mark# natsFrom X -> mark# X, mark# natsFrom X -> mark# X) (mark# natsFrom X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# natsFrom X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# natsFrom X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# fst X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# fst X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# fst X -> mark# X, mark# take(X1, X2) -> mark# X2) (mark# fst X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# fst X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# fst X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# fst X -> mark# X, mark# sel(X1, X2) -> mark# X2) (mark# fst X -> mark# X, mark# sel(X1, X2) -> mark# X1) (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> mark# X2) (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> mark# X1) (mark# fst X -> mark# X, mark# tail X -> tail# mark X) (mark# fst X -> mark# X, mark# tail X -> active# tail mark X) (mark# fst X -> mark# X, mark# tail X -> mark# X) (mark# fst X -> mark# X, mark# head X -> head# mark X) (mark# fst X -> mark# X, mark# head X -> active# head mark X) (mark# fst X -> mark# X, mark# head X -> mark# X) (mark# fst X -> mark# X, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# fst X -> mark# X, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# fst X -> mark# X, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# fst X -> mark# X, mark# 0() -> active# 0()) (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> mark# X2) (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> mark# X1) (mark# fst X -> mark# X, mark# nil() -> active# nil()) (mark# fst X -> mark# X, mark# snd X -> snd# mark X) (mark# fst X -> mark# X, mark# snd X -> active# snd mark X) (mark# fst X -> mark# X, mark# snd X -> mark# X) (mark# fst X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# fst X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# fst X -> mark# X, mark# pair(X1, X2) -> mark# X2) (mark# fst X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# fst X -> mark# X, mark# fst X -> fst# mark X) (mark# fst X -> mark# X, mark# fst X -> active# fst mark X) (mark# fst X -> mark# X, mark# fst X -> mark# X) (mark# fst X -> mark# X, mark# s X -> active# s mark X) (mark# fst X -> mark# X, mark# s X -> s# mark X) (mark# fst X -> mark# X, mark# s X -> mark# X) (mark# fst X -> mark# X, mark# natsFrom X -> active# natsFrom mark X) (mark# fst X -> mark# X, mark# natsFrom X -> natsFrom# mark X) (mark# fst X -> mark# X, mark# natsFrom X -> mark# X) (mark# fst X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# fst X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# fst X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# head X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# head X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# head X -> mark# X, mark# take(X1, X2) -> mark# X2) (mark# head X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# head X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# head X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# head X -> mark# X, mark# sel(X1, X2) -> mark# X2) (mark# head X -> mark# X, mark# sel(X1, X2) -> mark# X1) (mark# head X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# head X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# head X -> mark# X, mark# afterNth(X1, X2) -> mark# X2) (mark# head X -> mark# X, mark# afterNth(X1, X2) -> mark# X1) (mark# head X -> mark# X, mark# tail X -> tail# mark X) (mark# head X -> mark# X, mark# tail X -> active# tail mark X) (mark# head X -> mark# X, mark# tail X -> mark# X) (mark# head X -> mark# X, mark# head X -> head# mark X) (mark# head X -> mark# X, mark# head X -> active# head mark X) (mark# head X -> mark# X, mark# head X -> mark# X) (mark# head X -> mark# X, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# head X -> mark# X, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# head X -> mark# X, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# head X -> mark# X, mark# 0() -> active# 0()) (mark# head X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# head X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# head X -> mark# X, mark# splitAt(X1, X2) -> mark# X2) (mark# head X -> mark# X, mark# splitAt(X1, X2) -> mark# X1) (mark# head X -> mark# X, mark# nil() -> active# nil()) (mark# head X -> mark# X, mark# snd X -> snd# mark X) (mark# head X -> mark# X, mark# snd X -> active# snd mark X) (mark# head X -> mark# X, mark# snd X -> mark# X) (mark# head X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# head X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# head X -> mark# X, mark# pair(X1, X2) -> mark# X2) (mark# head X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# head X -> mark# X, mark# fst X -> fst# mark X) (mark# head X -> mark# X, mark# fst X -> active# fst mark X) (mark# head X -> mark# X, mark# fst X -> mark# X) (mark# head X -> mark# X, mark# s X -> active# s mark X) (mark# head X -> mark# X, mark# s X -> s# mark X) (mark# head X -> mark# X, mark# s X -> mark# X) (mark# head X -> mark# X, mark# natsFrom X -> active# natsFrom mark X) (mark# head X -> mark# X, mark# natsFrom X -> natsFrom# mark X) (mark# head X -> mark# X, mark# natsFrom X -> mark# X) (mark# head X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# head X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# head X -> mark# X, mark# cons(X1, X2) -> mark# X1) (natsFrom# mark X -> natsFrom# X, natsFrom# active X -> natsFrom# X) (natsFrom# mark X -> natsFrom# X, natsFrom# mark X -> natsFrom# X) (s# mark X -> s# X, s# active X -> s# X) (s# mark X -> s# X, s# mark X -> s# X) (fst# mark X -> fst# X, fst# active X -> fst# X) (fst# mark X -> fst# X, fst# mark X -> fst# X) (snd# mark X -> snd# X, snd# active X -> snd# X) (snd# mark X -> snd# X, snd# mark X -> snd# X) (head# mark X -> head# X, head# active X -> head# X) (head# mark X -> head# X, head# mark X -> head# X) (tail# mark X -> tail# X, tail# active X -> tail# X) (tail# mark X -> tail# X, tail# mark X -> tail# X) (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# tail X -> tail# mark X) (mark# cons(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X) (mark# cons(X1, X2) -> mark# X1, mark# tail X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# head X -> head# mark X) (mark# cons(X1, X2) -> mark# X1, mark# head X -> active# head mark X) (mark# cons(X1, X2) -> mark# X1, mark# head X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# cons(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# cons(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# cons(X1, X2) -> mark# X1, mark# snd X -> snd# mark X) (mark# cons(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X) (mark# cons(X1, X2) -> mark# X1, mark# snd X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# cons(X1, X2) -> mark# X1, mark# fst X -> fst# mark X) (mark# cons(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X) (mark# cons(X1, X2) -> mark# X1, mark# fst X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (mark# cons(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# cons(X1, X2) -> mark# X1, mark# s X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# cons(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# cons(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X) (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# head cons(N, XS) -> mark# N) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# snd pair(XS, YS) -> mark# YS) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# fst pair(XS, YS) -> mark# XS) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> s# N) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> natsFrom# s N) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# head cons(N, XS) -> mark# N) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# snd pair(XS, YS) -> mark# YS) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# fst pair(XS, YS) -> mark# XS) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> s# N) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> natsFrom# s N) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X1, mark# tail X -> tail# mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# tail X -> mark# X) (mark# afterNth(X1, X2) -> mark# X1, mark# head X -> head# mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# head X -> active# head mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# head X -> mark# X) (mark# afterNth(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# afterNth(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# afterNth(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# afterNth(X1, X2) -> mark# X1, mark# snd X -> snd# mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# snd X -> mark# X) (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X1, mark# fst X -> fst# mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# fst X -> mark# X) (mark# afterNth(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# s X -> mark# X) (mark# afterNth(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# afterNth(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X) (mark# afterNth(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# afterNth(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# tail X -> tail# mark X) (mark# sel(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X) (mark# sel(X1, X2) -> mark# X1, mark# tail X -> mark# X) (mark# sel(X1, X2) -> mark# X1, mark# head X -> head# mark X) (mark# sel(X1, X2) -> mark# X1, mark# head X -> active# head mark X) (mark# sel(X1, X2) -> mark# X1, mark# head X -> mark# X) (mark# sel(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# sel(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# sel(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# sel(X1, X2) -> mark# X1, mark# snd X -> snd# mark X) (mark# sel(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X) (mark# sel(X1, X2) -> mark# X1, mark# snd X -> mark# X) (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X1, mark# fst X -> fst# mark X) (mark# sel(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X) (mark# sel(X1, X2) -> mark# X1, mark# fst X -> mark# X) (mark# sel(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (mark# sel(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# sel(X1, X2) -> mark# X1, mark# s X -> mark# X) (mark# sel(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# sel(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# sel(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X) (mark# sel(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# sel(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# sel(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# tail X -> tail# mark X) (mark# take(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X) (mark# take(X1, X2) -> mark# X1, mark# tail X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# head X -> head# mark X) (mark# take(X1, X2) -> mark# X1, mark# head X -> active# head mark X) (mark# take(X1, X2) -> mark# X1, mark# head X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# take(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# take(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# take(X1, X2) -> mark# X1, mark# snd X -> snd# mark X) (mark# take(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X) (mark# take(X1, X2) -> mark# X1, mark# snd X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X1, mark# fst X -> fst# mark X) (mark# take(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X) (mark# take(X1, X2) -> mark# X1, mark# fst X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (mark# take(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# take(X1, X2) -> mark# X1, mark# s X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# take(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# take(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X) (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> mark# X2) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> mark# X2) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> mark# X2) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tail X -> tail# mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tail X -> active# tail mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tail X -> mark# X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# head X -> head# mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# head X -> active# head mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# head X -> mark# X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# u(X1, X2, X3, X4) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# 0() -> active# 0()) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> mark# X2) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# nil() -> active# nil()) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# snd X -> snd# mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# snd X -> active# snd mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# snd X -> mark# X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> mark# X2) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> mark# X1) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# fst X -> fst# mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# fst X -> active# fst mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# fst X -> mark# X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# s X -> active# s mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# s X -> s# mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# s X -> mark# X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# natsFrom X -> active# natsFrom mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# natsFrom X -> natsFrom# mark X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# natsFrom X -> mark# X) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# cons(X1, X2) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> mark# X2) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> mark# X2) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> mark# X2) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tail X -> tail# mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tail X -> active# tail mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tail X -> mark# X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# head X -> head# mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# head X -> active# head mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# head X -> mark# X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# u(X1, X2, X3, X4) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# 0() -> active# 0()) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> mark# X2) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# nil() -> active# nil()) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# snd X -> snd# mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# snd X -> active# snd mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# snd X -> mark# X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> mark# X2) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> mark# X1) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# fst X -> fst# mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# fst X -> active# fst mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# fst X -> mark# X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# s X -> active# s mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# s X -> s# mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# s X -> mark# X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# natsFrom X -> active# natsFrom mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# natsFrom X -> natsFrom# mark X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# natsFrom X -> mark# X) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# cons(X1, X2) -> mark# X1) (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# active X -> snd# X) (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# mark X -> snd# X) (active# take(N, XS) -> fst# splitAt(N, XS), fst# active X -> fst# X) (active# take(N, XS) -> fst# splitAt(N, XS), fst# mark X -> fst# X) (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X2, mark# tail X -> tail# mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# tail X -> mark# X) (mark# splitAt(X1, X2) -> mark# X2, mark# head X -> head# mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# head X -> active# head mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# head X -> mark# X) (mark# splitAt(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# splitAt(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# splitAt(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X2, mark# 0() -> active# 0()) (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X2, mark# nil() -> active# nil()) (mark# splitAt(X1, X2) -> mark# X2, mark# snd X -> snd# mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# snd X -> mark# X) (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X2, mark# fst X -> fst# mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# fst X -> mark# X) (mark# splitAt(X1, X2) -> mark# X2, mark# s X -> active# s mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# s X -> s# mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# s X -> mark# X) (mark# splitAt(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X) (mark# splitAt(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X) (mark# splitAt(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# splitAt(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# tail X -> tail# mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# tail X -> mark# X) (mark# afterNth(X1, X2) -> mark# X2, mark# head X -> head# mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# head X -> active# head mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# head X -> mark# X) (mark# afterNth(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# afterNth(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# afterNth(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# 0() -> active# 0()) (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# nil() -> active# nil()) (mark# afterNth(X1, X2) -> mark# X2, mark# snd X -> snd# mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# snd X -> mark# X) (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2) (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1) (mark# afterNth(X1, X2) -> mark# X2, mark# fst X -> fst# mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# fst X -> mark# X) (mark# afterNth(X1, X2) -> mark# X2, mark# s X -> active# s mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# s X -> s# mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# s X -> mark# X) (mark# afterNth(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X) (mark# afterNth(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X) (mark# afterNth(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# afterNth(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# tail X -> tail# mark X) (mark# take(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X) (mark# take(X1, X2) -> mark# X2, mark# tail X -> mark# X) (mark# take(X1, X2) -> mark# X2, mark# head X -> head# mark X) (mark# take(X1, X2) -> mark# X2, mark# head X -> active# head mark X) (mark# take(X1, X2) -> mark# X2, mark# head X -> mark# X) (mark# take(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# take(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# take(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# 0() -> active# 0()) (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# nil() -> active# nil()) (mark# take(X1, X2) -> mark# X2, mark# snd X -> snd# mark X) (mark# take(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X) (mark# take(X1, X2) -> mark# X2, mark# snd X -> mark# X) (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2) (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1) (mark# take(X1, X2) -> mark# X2, mark# fst X -> fst# mark X) (mark# take(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X) (mark# take(X1, X2) -> mark# X2, mark# fst X -> mark# X) (mark# take(X1, X2) -> mark# X2, mark# s X -> active# s mark X) (mark# take(X1, X2) -> mark# X2, mark# s X -> s# mark X) (mark# take(X1, X2) -> mark# X2, mark# s X -> mark# X) (mark# take(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X) (mark# take(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X) (mark# take(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X) (mark# take(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# take(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# take(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1) (mark# natsFrom X -> active# natsFrom mark X, active# take(N, XS) -> splitAt#(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# take(N, XS) -> fst# splitAt(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# sel(N, XS) -> afterNth#(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# sel(N, XS) -> head# afterNth(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# tail cons(N, XS) -> mark# XS) (mark# natsFrom X -> active# natsFrom mark X, active# head cons(N, XS) -> mark# N) (mark# natsFrom X -> active# natsFrom mark X, active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# natsFrom X -> active# natsFrom mark X, active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# natsFrom X -> active# natsFrom mark X, active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# natsFrom X -> active# natsFrom mark X, active# snd pair(XS, YS) -> mark# YS) (mark# natsFrom X -> active# natsFrom mark X, active# fst pair(XS, YS) -> mark# XS) (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> s# N) (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> natsFrom# s N) (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> cons#(N, natsFrom s N)) (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# fst X -> active# fst mark X, active# take(N, XS) -> splitAt#(N, XS)) (mark# fst X -> active# fst mark X, active# take(N, XS) -> fst# splitAt(N, XS)) (mark# fst X -> active# fst mark X, active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# fst X -> active# fst mark X, active# sel(N, XS) -> afterNth#(N, XS)) (mark# fst X -> active# fst mark X, active# sel(N, XS) -> head# afterNth(N, XS)) (mark# fst X -> active# fst mark X, active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# fst X -> active# fst mark X, active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# fst X -> active# fst mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# fst X -> active# fst mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# fst X -> active# fst mark X, active# tail cons(N, XS) -> mark# XS) (mark# fst X -> active# fst mark X, active# head cons(N, XS) -> mark# N) (mark# fst X -> active# fst mark X, active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# fst X -> active# fst mark X, active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# fst X -> active# fst mark X, active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# fst X -> active# fst mark X, active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# fst X -> active# fst mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# fst X -> active# fst mark X, active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# fst X -> active# fst mark X, active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# fst X -> active# fst mark X, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# fst X -> active# fst mark X, active# snd pair(XS, YS) -> mark# YS) (mark# fst X -> active# fst mark X, active# fst pair(XS, YS) -> mark# XS) (mark# fst X -> active# fst mark X, active# natsFrom N -> s# N) (mark# fst X -> active# fst mark X, active# natsFrom N -> natsFrom# s N) (mark# fst X -> active# fst mark X, active# natsFrom N -> cons#(N, natsFrom s N)) (mark# fst X -> active# fst mark X, active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# head X -> active# head mark X, active# take(N, XS) -> splitAt#(N, XS)) (mark# head X -> active# head mark X, active# take(N, XS) -> fst# splitAt(N, XS)) (mark# head X -> active# head mark X, active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# head X -> active# head mark X, active# sel(N, XS) -> afterNth#(N, XS)) (mark# head X -> active# head mark X, active# sel(N, XS) -> head# afterNth(N, XS)) (mark# head X -> active# head mark X, active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# head X -> active# head mark X, active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# head X -> active# head mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# head X -> active# head mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# head X -> active# head mark X, active# tail cons(N, XS) -> mark# XS) (mark# head X -> active# head mark X, active# head cons(N, XS) -> mark# N) (mark# head X -> active# head mark X, active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# head X -> active# head mark X, active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# head X -> active# head mark X, active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# head X -> active# head mark X, active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# head X -> active# head mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# head X -> active# head mark X, active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# head X -> active# head mark X, active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# head X -> active# head mark X, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# head X -> active# head mark X, active# snd pair(XS, YS) -> mark# YS) (mark# head X -> active# head mark X, active# fst pair(XS, YS) -> mark# XS) (mark# head X -> active# head mark X, active# natsFrom N -> s# N) (mark# head X -> active# head mark X, active# natsFrom N -> natsFrom# s N) (mark# head X -> active# head mark X, active# natsFrom N -> cons#(N, natsFrom s N)) (mark# head X -> active# head mark X, active# natsFrom N -> mark# cons(N, natsFrom s N)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> mark# X2) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> mark# X1) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> mark# X2) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> mark# X1) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X2) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X1) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tail X -> tail# mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tail X -> active# tail mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tail X -> mark# X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# head X -> head# mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# head X -> active# head mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# head X -> mark# X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# u(X1, X2, X3, X4) -> mark# X1) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# 0() -> active# 0()) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X2) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X1) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# nil() -> active# nil()) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# snd X -> snd# mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# snd X -> active# snd mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# snd X -> mark# X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> mark# X2) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> mark# X1) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# fst X -> fst# mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# fst X -> active# fst mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# fst X -> mark# X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# s X -> active# s mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# s X -> s# mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# s X -> mark# X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# natsFrom X -> active# natsFrom mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# natsFrom X -> natsFrom# mark X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# natsFrom X -> mark# X) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# cons(X1, X2) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> mark# X2) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> mark# X2) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X2) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tail X -> tail# mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tail X -> active# tail mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tail X -> mark# X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# head X -> head# mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# head X -> active# head mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# head X -> mark# X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# u(X1, X2, X3, X4) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# 0() -> active# 0()) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X2) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# nil() -> active# nil()) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# snd X -> snd# mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# snd X -> active# snd mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# snd X -> mark# X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> mark# X2) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> mark# X1) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# fst X -> fst# mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# fst X -> active# fst mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# fst X -> mark# X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# s X -> active# s mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# s X -> s# mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# s X -> mark# X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# natsFrom X -> active# natsFrom mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# natsFrom X -> natsFrom# mark X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# natsFrom X -> mark# X) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# cons(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(active X1, X2) -> afterNth#(X1, X2)) (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(mark X1, X2) -> afterNth#(X1, X2)) (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, active X2) -> afterNth#(X1, X2)) (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, mark X2) -> afterNth#(X1, X2)) (active# take(N, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (active# take(N, XS) -> splitAt#(N, XS), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (active# take(N, XS) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (active# take(N, XS) -> splitAt#(N, XS), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, mark X2) -> pair#(X1, X2)) (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, active X2) -> pair#(X1, X2)) (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(mark X1, X2) -> pair#(X1, X2)) (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(active X1, X2) -> pair#(X1, X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# cons(X1, X2) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# natsFrom X -> mark# X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# natsFrom X -> natsFrom# mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# natsFrom X -> active# natsFrom mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# s X -> mark# X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# s X -> s# mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# s X -> active# s mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# fst X -> mark# X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# fst X -> active# fst mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# fst X -> fst# mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> mark# X2) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# snd X -> mark# X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# snd X -> active# snd mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# snd X -> snd# mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# nil() -> active# nil()) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> mark# X2) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# 0() -> active# 0()) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# u(X1, X2, X3, X4) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# head X -> mark# X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# head X -> active# head mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# head X -> head# mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tail X -> mark# X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tail X -> active# tail mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tail X -> tail# mark X) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> mark# X2) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> mark# X2) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> mark# X1) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> mark# X2) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# tail X -> active# tail mark X, active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# tail X -> active# tail mark X, active# natsFrom N -> cons#(N, natsFrom s N)) (mark# tail X -> active# tail mark X, active# natsFrom N -> natsFrom# s N) (mark# tail X -> active# tail mark X, active# natsFrom N -> s# N) (mark# tail X -> active# tail mark X, active# fst pair(XS, YS) -> mark# XS) (mark# tail X -> active# tail mark X, active# snd pair(XS, YS) -> mark# YS) (mark# tail X -> active# tail mark X, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# tail X -> active# tail mark X, active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# tail X -> active# tail mark X, active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# tail X -> active# tail mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# tail X -> active# tail mark X, active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# tail X -> active# tail mark X, active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# tail X -> active# tail mark X, active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# tail X -> active# tail mark X, active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# tail X -> active# tail mark X, active# head cons(N, XS) -> mark# N) (mark# tail X -> active# tail mark X, active# tail cons(N, XS) -> mark# XS) (mark# tail X -> active# tail mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# tail X -> active# tail mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# tail X -> active# tail mark X, active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# tail X -> active# tail mark X, active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# tail X -> active# tail mark X, active# sel(N, XS) -> head# afterNth(N, XS)) (mark# tail X -> active# tail mark X, active# sel(N, XS) -> afterNth#(N, XS)) (mark# tail X -> active# tail mark X, active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# tail X -> active# tail mark X, active# take(N, XS) -> fst# splitAt(N, XS)) (mark# tail X -> active# tail mark X, active# take(N, XS) -> splitAt#(N, XS)) (mark# snd X -> active# snd mark X, active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# snd X -> active# snd mark X, active# natsFrom N -> cons#(N, natsFrom s N)) (mark# snd X -> active# snd mark X, active# natsFrom N -> natsFrom# s N) (mark# snd X -> active# snd mark X, active# natsFrom N -> s# N) (mark# snd X -> active# snd mark X, active# fst pair(XS, YS) -> mark# XS) (mark# snd X -> active# snd mark X, active# snd pair(XS, YS) -> mark# YS) (mark# snd X -> active# snd mark X, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# snd X -> active# snd mark X, active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# snd X -> active# snd mark X, active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# snd X -> active# snd mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# snd X -> active# snd mark X, active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# snd X -> active# snd mark X, active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# snd X -> active# snd mark X, active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# snd X -> active# snd mark X, active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# snd X -> active# snd mark X, active# head cons(N, XS) -> mark# N) (mark# snd X -> active# snd mark X, active# tail cons(N, XS) -> mark# XS) (mark# snd X -> active# snd mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# snd X -> active# snd mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# snd X -> active# snd mark X, active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# snd X -> active# snd mark X, active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# snd X -> active# snd mark X, active# sel(N, XS) -> head# afterNth(N, XS)) (mark# snd X -> active# snd mark X, active# sel(N, XS) -> afterNth#(N, XS)) (mark# snd X -> active# snd mark X, active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# snd X -> active# snd mark X, active# take(N, XS) -> fst# splitAt(N, XS)) (mark# snd X -> active# snd mark X, active# take(N, XS) -> splitAt#(N, XS)) (mark# s X -> active# s mark X, active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# s X -> active# s mark X, active# natsFrom N -> cons#(N, natsFrom s N)) (mark# s X -> active# s mark X, active# natsFrom N -> natsFrom# s N) (mark# s X -> active# s mark X, active# natsFrom N -> s# N) (mark# s X -> active# s mark X, active# fst pair(XS, YS) -> mark# XS) (mark# s X -> active# s mark X, active# snd pair(XS, YS) -> mark# YS) (mark# s X -> active# s mark X, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# s X -> active# s mark X, active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# s X -> active# s mark X, active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# s X -> active# s mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# s X -> active# s mark X, active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# s X -> active# s mark X, active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# s X -> active# s mark X, active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# s X -> active# s mark X, active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# s X -> active# s mark X, active# head cons(N, XS) -> mark# N) (mark# s X -> active# s mark X, active# tail cons(N, XS) -> mark# XS) (mark# s X -> active# s mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# s X -> active# s mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# s X -> active# s mark X, active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# s X -> active# s mark X, active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# s X -> active# s mark X, active# sel(N, XS) -> head# afterNth(N, XS)) (mark# s X -> active# s mark X, active# sel(N, XS) -> afterNth#(N, XS)) (mark# s X -> active# s mark X, active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# s X -> active# s mark X, active# take(N, XS) -> fst# splitAt(N, XS)) (mark# s X -> active# s mark X, active# take(N, XS) -> splitAt#(N, XS)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# cons(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# natsFrom X -> mark# X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# natsFrom X -> natsFrom# mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# natsFrom X -> active# natsFrom mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# s X -> mark# X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# s X -> s# mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# s X -> active# s mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# fst X -> mark# X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# fst X -> active# fst mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# fst X -> fst# mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# pair(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# pair(X1, X2) -> mark# X2) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# snd X -> mark# X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# snd X -> active# snd mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# snd X -> snd# mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# nil() -> active# nil()) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# splitAt(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# splitAt(X1, X2) -> mark# X2) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# 0() -> active# 0()) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# u(X1, X2, X3, X4) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# head X -> mark# X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# head X -> active# head mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# head X -> head# mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# tail X -> mark# X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# tail X -> active# tail mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# tail X -> tail# mark X) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# afterNth(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# afterNth(X1, X2) -> mark# X2) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# sel(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# sel(X1, X2) -> mark# X2) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# take(X1, X2) -> mark# X1) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# take(X1, X2) -> mark# X2) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# sel(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# sel(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X) (mark# sel(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X) (mark# sel(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X) (mark# sel(X1, X2) -> mark# X2, mark# s X -> mark# X) (mark# sel(X1, X2) -> mark# X2, mark# s X -> s# mark X) (mark# sel(X1, X2) -> mark# X2, mark# s X -> active# s mark X) (mark# sel(X1, X2) -> mark# X2, mark# fst X -> mark# X) (mark# sel(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X) (mark# sel(X1, X2) -> mark# X2, mark# fst X -> fst# mark X) (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# snd X -> mark# X) (mark# sel(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X) (mark# sel(X1, X2) -> mark# X2, mark# snd X -> snd# mark X) (mark# sel(X1, X2) -> mark# X2, mark# nil() -> active# nil()) (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# 0() -> active# 0()) (mark# sel(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# sel(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# sel(X1, X2) -> mark# X2, mark# head X -> mark# X) (mark# sel(X1, X2) -> mark# X2, mark# head X -> active# head mark X) (mark# sel(X1, X2) -> mark# X2, mark# head X -> head# mark X) (mark# sel(X1, X2) -> mark# X2, mark# tail X -> mark# X) (mark# sel(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X) (mark# sel(X1, X2) -> mark# X2, mark# tail X -> tail# mark X) (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1) (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2) (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# natsFrom N -> natsFrom# s N) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# natsFrom N -> s# N) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# fst pair(XS, YS) -> mark# XS) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# snd pair(XS, YS) -> mark# YS) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# head cons(N, XS) -> mark# N) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# tail cons(N, XS) -> mark# XS) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# sel(N, XS) -> afterNth#(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), active# take(N, XS) -> splitAt#(N, XS)) (mark# pair(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# pair(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# pair(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X) (mark# pair(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X) (mark# pair(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X) (mark# pair(X1, X2) -> mark# X2, mark# s X -> mark# X) (mark# pair(X1, X2) -> mark# X2, mark# s X -> s# mark X) (mark# pair(X1, X2) -> mark# X2, mark# s X -> active# s mark X) (mark# pair(X1, X2) -> mark# X2, mark# fst X -> mark# X) (mark# pair(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X) (mark# pair(X1, X2) -> mark# X2, mark# fst X -> fst# mark X) (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# snd X -> mark# X) (mark# pair(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X) (mark# pair(X1, X2) -> mark# X2, mark# snd X -> snd# mark X) (mark# pair(X1, X2) -> mark# X2, mark# nil() -> active# nil()) (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# 0() -> active# 0()) (mark# pair(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# pair(X1, X2) -> mark# X2, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# pair(X1, X2) -> mark# X2, mark# head X -> mark# X) (mark# pair(X1, X2) -> mark# X2, mark# head X -> active# head mark X) (mark# pair(X1, X2) -> mark# X2, mark# head X -> head# mark X) (mark# pair(X1, X2) -> mark# X2, mark# tail X -> mark# X) (mark# pair(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X) (mark# pair(X1, X2) -> mark# X2, mark# tail X -> tail# mark X) (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# sel(N, XS) -> head# afterNth(N, XS), head# mark X -> head# X) (active# sel(N, XS) -> head# afterNth(N, XS), head# active X -> head# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# cons(X1, X2) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# natsFrom X -> mark# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# natsFrom X -> natsFrom# mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# natsFrom X -> active# natsFrom mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# s X -> mark# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# s X -> s# mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# s X -> active# s mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# fst X -> mark# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# fst X -> active# fst mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# fst X -> fst# mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> mark# X2) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# snd X -> mark# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# snd X -> active# snd mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# snd X -> snd# mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# nil() -> active# nil()) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> mark# X2) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# 0() -> active# 0()) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# u(X1, X2, X3, X4) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# head X -> mark# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# head X -> active# head mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# head X -> head# mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# tail X -> mark# X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# tail X -> active# tail mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# tail X -> tail# mark X) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> mark# X2) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> mark# X2) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> mark# X1) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> mark# X2) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> natsFrom# s N) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> s# N) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# fst pair(XS, YS) -> mark# XS) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# snd pair(XS, YS) -> mark# YS) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# head cons(N, XS) -> mark# N) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# tail cons(N, XS) -> mark# XS) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sel(N, XS) -> afterNth#(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# take(N, XS) -> splitAt#(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> natsFrom# s N) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> s# N) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# fst pair(XS, YS) -> mark# XS) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# snd pair(XS, YS) -> mark# YS) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# head cons(N, XS) -> mark# N) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> natsFrom# s N) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> s# N) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# fst pair(XS, YS) -> mark# XS) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# snd pair(XS, YS) -> mark# YS) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# head cons(N, XS) -> mark# N) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> natsFrom# s N) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> s# N) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# fst pair(XS, YS) -> mark# XS) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# snd pair(XS, YS) -> mark# YS) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# head cons(N, XS) -> mark# N) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# natsFrom X -> mark# X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# s X -> mark# X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# s X -> s# mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# s X -> active# s mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# fst X -> mark# X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# fst X -> active# fst mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# fst X -> fst# mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# snd X -> mark# X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# snd X -> active# snd mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# snd X -> snd# mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# nil() -> active# nil()) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# 0() -> active# 0()) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# head X -> mark# X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# head X -> active# head mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# head X -> head# mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# tail X -> mark# X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# tail X -> active# tail mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# tail X -> tail# mark X) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# u(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X) (mark# splitAt(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# s X -> mark# X) (mark# splitAt(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# fst X -> mark# X) (mark# splitAt(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# fst X -> fst# mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# snd X -> mark# X) (mark# splitAt(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# snd X -> snd# mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# splitAt(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# splitAt(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# splitAt(X1, X2) -> mark# X1, mark# head X -> mark# X) (mark# splitAt(X1, X2) -> mark# X1, mark# head X -> active# head mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# head X -> head# mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# tail X -> mark# X) (mark# splitAt(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# tail X -> tail# mark X) (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# pair(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X) (mark# pair(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X) (mark# pair(X1, X2) -> mark# X1, mark# s X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# s X -> s# mark X) (mark# pair(X1, X2) -> mark# X1, mark# s X -> active# s mark X) (mark# pair(X1, X2) -> mark# X1, mark# fst X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X) (mark# pair(X1, X2) -> mark# X1, mark# fst X -> fst# mark X) (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# snd X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X) (mark# pair(X1, X2) -> mark# X1, mark# snd X -> snd# mark X) (mark# pair(X1, X2) -> mark# X1, mark# nil() -> active# nil()) (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# 0() -> active# 0()) (mark# pair(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# pair(X1, X2) -> mark# X1, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# pair(X1, X2) -> mark# X1, mark# head X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# head X -> active# head mark X) (mark# pair(X1, X2) -> mark# X1, mark# head X -> head# mark X) (mark# pair(X1, X2) -> mark# X1, mark# tail X -> mark# X) (mark# pair(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X) (mark# pair(X1, X2) -> mark# X1, mark# tail X -> tail# mark X) (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1) (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2) (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2)) (tail# active X -> tail# X, tail# mark X -> tail# X) (tail# active X -> tail# X, tail# active X -> tail# X) (head# active X -> head# X, head# mark X -> head# X) (head# active X -> head# X, head# active X -> head# X) (snd# active X -> snd# X, snd# mark X -> snd# X) (snd# active X -> snd# X, snd# active X -> snd# X) (fst# active X -> fst# X, fst# mark X -> fst# X) (fst# active X -> fst# X, fst# active X -> fst# X) (s# active X -> s# X, s# mark X -> s# X) (s# active X -> s# X, s# active X -> s# X) (natsFrom# active X -> natsFrom# X, natsFrom# mark X -> natsFrom# X) (natsFrom# active X -> natsFrom# X, natsFrom# active X -> natsFrom# X) (mark# tail X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# tail X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# tail X -> mark# X, mark# natsFrom X -> mark# X) (mark# tail X -> mark# X, mark# natsFrom X -> natsFrom# mark X) (mark# tail X -> mark# X, mark# natsFrom X -> active# natsFrom mark X) (mark# tail X -> mark# X, mark# s X -> mark# X) (mark# tail X -> mark# X, mark# s X -> s# mark X) (mark# tail X -> mark# X, mark# s X -> active# s mark X) (mark# tail X -> mark# X, mark# fst X -> mark# X) (mark# tail X -> mark# X, mark# fst X -> active# fst mark X) (mark# tail X -> mark# X, mark# fst X -> fst# mark X) (mark# tail X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# pair(X1, X2) -> mark# X2) (mark# tail X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# tail X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# tail X -> mark# X, mark# snd X -> mark# X) (mark# tail X -> mark# X, mark# snd X -> active# snd mark X) (mark# tail X -> mark# X, mark# snd X -> snd# mark X) (mark# tail X -> mark# X, mark# nil() -> active# nil()) (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> mark# X2) (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# tail X -> mark# X, mark# 0() -> active# 0()) (mark# tail X -> mark# X, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# tail X -> mark# X, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# tail X -> mark# X, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# tail X -> mark# X, mark# head X -> mark# X) (mark# tail X -> mark# X, mark# head X -> active# head mark X) (mark# tail X -> mark# X, mark# head X -> head# mark X) (mark# tail X -> mark# X, mark# tail X -> mark# X) (mark# tail X -> mark# X, mark# tail X -> active# tail mark X) (mark# tail X -> mark# X, mark# tail X -> tail# mark X) (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> mark# X2) (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# tail X -> mark# X, mark# sel(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# sel(X1, X2) -> mark# X2) (mark# tail X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# tail X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# tail X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# tail X -> mark# X, mark# take(X1, X2) -> mark# X2) (mark# tail X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# tail X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# snd X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# snd X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# snd X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# snd X -> mark# X, mark# natsFrom X -> mark# X) (mark# snd X -> mark# X, mark# natsFrom X -> natsFrom# mark X) (mark# snd X -> mark# X, mark# natsFrom X -> active# natsFrom mark X) (mark# snd X -> mark# X, mark# s X -> mark# X) (mark# snd X -> mark# X, mark# s X -> s# mark X) (mark# snd X -> mark# X, mark# s X -> active# s mark X) (mark# snd X -> mark# X, mark# fst X -> mark# X) (mark# snd X -> mark# X, mark# fst X -> active# fst mark X) (mark# snd X -> mark# X, mark# fst X -> fst# mark X) (mark# snd X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# snd X -> mark# X, mark# pair(X1, X2) -> mark# X2) (mark# snd X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# snd X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# snd X -> mark# X, mark# snd X -> mark# X) (mark# snd X -> mark# X, mark# snd X -> active# snd mark X) (mark# snd X -> mark# X, mark# snd X -> snd# mark X) (mark# snd X -> mark# X, mark# nil() -> active# nil()) (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> mark# X1) (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> mark# X2) (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# snd X -> mark# X, mark# 0() -> active# 0()) (mark# snd X -> mark# X, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# snd X -> mark# X, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# snd X -> mark# X, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# snd X -> mark# X, mark# head X -> mark# X) (mark# snd X -> mark# X, mark# head X -> active# head mark X) (mark# snd X -> mark# X, mark# head X -> head# mark X) (mark# snd X -> mark# X, mark# tail X -> mark# X) (mark# snd X -> mark# X, mark# tail X -> active# tail mark X) (mark# snd X -> mark# X, mark# tail X -> tail# mark X) (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> mark# X1) (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> mark# X2) (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# snd X -> mark# X, mark# sel(X1, X2) -> mark# X1) (mark# snd X -> mark# X, mark# sel(X1, X2) -> mark# X2) (mark# snd X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# snd X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# snd X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# snd X -> mark# X, mark# take(X1, X2) -> mark# X2) (mark# snd X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# snd X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# s X -> mark# X, mark# cons(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2)) (mark# s X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (mark# s X -> mark# X, mark# natsFrom X -> mark# X) (mark# s X -> mark# X, mark# natsFrom X -> natsFrom# mark X) (mark# s X -> mark# X, mark# natsFrom X -> active# natsFrom mark X) (mark# s X -> mark# X, mark# s X -> mark# X) (mark# s X -> mark# X, mark# s X -> s# mark X) (mark# s X -> mark# X, mark# s X -> active# s mark X) (mark# s X -> mark# X, mark# fst X -> mark# X) (mark# s X -> mark# X, mark# fst X -> active# fst mark X) (mark# s X -> mark# X, mark# fst X -> fst# mark X) (mark# s X -> mark# X, mark# pair(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# pair(X1, X2) -> mark# X2) (mark# s X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (mark# s X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (mark# s X -> mark# X, mark# snd X -> mark# X) (mark# s X -> mark# X, mark# snd X -> active# snd mark X) (mark# s X -> mark# X, mark# snd X -> snd# mark X) (mark# s X -> mark# X, mark# nil() -> active# nil()) (mark# s X -> mark# X, mark# splitAt(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# splitAt(X1, X2) -> mark# X2) (mark# s X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (mark# s X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (mark# s X -> mark# X, mark# 0() -> active# 0()) (mark# s X -> mark# X, mark# u(X1, X2, X3, X4) -> mark# X1) (mark# s X -> mark# X, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (mark# s X -> mark# X, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (mark# s X -> mark# X, mark# head X -> mark# X) (mark# s X -> mark# X, mark# head X -> active# head mark X) (mark# s X -> mark# X, mark# head X -> head# mark X) (mark# s X -> mark# X, mark# tail X -> mark# X) (mark# s X -> mark# X, mark# tail X -> active# tail mark X) (mark# s X -> mark# X, mark# tail X -> tail# mark X) (mark# s X -> mark# X, mark# afterNth(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# afterNth(X1, X2) -> mark# X2) (mark# s X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (mark# s X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (mark# s X -> mark# X, mark# sel(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# sel(X1, X2) -> mark# X2) (mark# s X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (mark# s X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (mark# s X -> mark# X, mark# take(X1, X2) -> mark# X1) (mark# s X -> mark# X, mark# take(X1, X2) -> mark# X2) (mark# s X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (mark# s X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# cons(X1, X2) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# snd pair(XS, YS) -> mark# YS, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# snd pair(XS, YS) -> mark# YS, mark# natsFrom X -> mark# X) (active# snd pair(XS, YS) -> mark# YS, mark# natsFrom X -> natsFrom# mark X) (active# snd pair(XS, YS) -> mark# YS, mark# natsFrom X -> active# natsFrom mark X) (active# snd pair(XS, YS) -> mark# YS, mark# s X -> mark# X) (active# snd pair(XS, YS) -> mark# YS, mark# s X -> s# mark X) (active# snd pair(XS, YS) -> mark# YS, mark# s X -> active# s mark X) (active# snd pair(XS, YS) -> mark# YS, mark# fst X -> mark# X) (active# snd pair(XS, YS) -> mark# YS, mark# fst X -> active# fst mark X) (active# snd pair(XS, YS) -> mark# YS, mark# fst X -> fst# mark X) (active# snd pair(XS, YS) -> mark# YS, mark# pair(X1, X2) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# pair(X1, X2) -> mark# X2) (active# snd pair(XS, YS) -> mark# YS, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# snd X -> mark# X) (active# snd pair(XS, YS) -> mark# YS, mark# snd X -> active# snd mark X) (active# snd pair(XS, YS) -> mark# YS, mark# snd X -> snd# mark X) (active# snd pair(XS, YS) -> mark# YS, mark# nil() -> active# nil()) (active# snd pair(XS, YS) -> mark# YS, mark# splitAt(X1, X2) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# splitAt(X1, X2) -> mark# X2) (active# snd pair(XS, YS) -> mark# YS, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# 0() -> active# 0()) (active# snd pair(XS, YS) -> mark# YS, mark# u(X1, X2, X3, X4) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# snd pair(XS, YS) -> mark# YS, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# snd pair(XS, YS) -> mark# YS, mark# head X -> mark# X) (active# snd pair(XS, YS) -> mark# YS, mark# head X -> active# head mark X) (active# snd pair(XS, YS) -> mark# YS, mark# head X -> head# mark X) (active# snd pair(XS, YS) -> mark# YS, mark# tail X -> mark# X) (active# snd pair(XS, YS) -> mark# YS, mark# tail X -> active# tail mark X) (active# snd pair(XS, YS) -> mark# YS, mark# tail X -> tail# mark X) (active# snd pair(XS, YS) -> mark# YS, mark# afterNth(X1, X2) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# afterNth(X1, X2) -> mark# X2) (active# snd pair(XS, YS) -> mark# YS, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# sel(X1, X2) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# sel(X1, X2) -> mark# X2) (active# snd pair(XS, YS) -> mark# YS, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# take(X1, X2) -> mark# X1) (active# snd pair(XS, YS) -> mark# YS, mark# take(X1, X2) -> mark# X2) (active# snd pair(XS, YS) -> mark# YS, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# snd pair(XS, YS) -> mark# YS, mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# cons(X1, X2) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# fst pair(XS, YS) -> mark# XS, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# fst pair(XS, YS) -> mark# XS, mark# natsFrom X -> mark# X) (active# fst pair(XS, YS) -> mark# XS, mark# natsFrom X -> natsFrom# mark X) (active# fst pair(XS, YS) -> mark# XS, mark# natsFrom X -> active# natsFrom mark X) (active# fst pair(XS, YS) -> mark# XS, mark# s X -> mark# X) (active# fst pair(XS, YS) -> mark# XS, mark# s X -> s# mark X) (active# fst pair(XS, YS) -> mark# XS, mark# s X -> active# s mark X) (active# fst pair(XS, YS) -> mark# XS, mark# fst X -> mark# X) (active# fst pair(XS, YS) -> mark# XS, mark# fst X -> active# fst mark X) (active# fst pair(XS, YS) -> mark# XS, mark# fst X -> fst# mark X) (active# fst pair(XS, YS) -> mark# XS, mark# pair(X1, X2) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# pair(X1, X2) -> mark# X2) (active# fst pair(XS, YS) -> mark# XS, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# snd X -> mark# X) (active# fst pair(XS, YS) -> mark# XS, mark# snd X -> active# snd mark X) (active# fst pair(XS, YS) -> mark# XS, mark# snd X -> snd# mark X) (active# fst pair(XS, YS) -> mark# XS, mark# nil() -> active# nil()) (active# fst pair(XS, YS) -> mark# XS, mark# splitAt(X1, X2) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# splitAt(X1, X2) -> mark# X2) (active# fst pair(XS, YS) -> mark# XS, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# 0() -> active# 0()) (active# fst pair(XS, YS) -> mark# XS, mark# u(X1, X2, X3, X4) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# fst pair(XS, YS) -> mark# XS, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# fst pair(XS, YS) -> mark# XS, mark# head X -> mark# X) (active# fst pair(XS, YS) -> mark# XS, mark# head X -> active# head mark X) (active# fst pair(XS, YS) -> mark# XS, mark# head X -> head# mark X) (active# fst pair(XS, YS) -> mark# XS, mark# tail X -> mark# X) (active# fst pair(XS, YS) -> mark# XS, mark# tail X -> active# tail mark X) (active# fst pair(XS, YS) -> mark# XS, mark# tail X -> tail# mark X) (active# fst pair(XS, YS) -> mark# XS, mark# afterNth(X1, X2) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# afterNth(X1, X2) -> mark# X2) (active# fst pair(XS, YS) -> mark# XS, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# sel(X1, X2) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# sel(X1, X2) -> mark# X2) (active# fst pair(XS, YS) -> mark# XS, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# take(X1, X2) -> mark# X1) (active# fst pair(XS, YS) -> mark# XS, mark# take(X1, X2) -> mark# X2) (active# fst pair(XS, YS) -> mark# XS, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# fst pair(XS, YS) -> mark# XS, mark# take(X1, X2) -> take#(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# cons(X1, X2) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# cons(X1, X2) -> cons#(mark X1, X2)) (active# head cons(N, XS) -> mark# N, mark# cons(X1, X2) -> active# cons(mark X1, X2)) (active# head cons(N, XS) -> mark# N, mark# natsFrom X -> mark# X) (active# head cons(N, XS) -> mark# N, mark# natsFrom X -> natsFrom# mark X) (active# head cons(N, XS) -> mark# N, mark# natsFrom X -> active# natsFrom mark X) (active# head cons(N, XS) -> mark# N, mark# s X -> mark# X) (active# head cons(N, XS) -> mark# N, mark# s X -> s# mark X) (active# head cons(N, XS) -> mark# N, mark# s X -> active# s mark X) (active# head cons(N, XS) -> mark# N, mark# fst X -> mark# X) (active# head cons(N, XS) -> mark# N, mark# fst X -> active# fst mark X) (active# head cons(N, XS) -> mark# N, mark# fst X -> fst# mark X) (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> mark# X2) (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> active# pair(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> pair#(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# snd X -> mark# X) (active# head cons(N, XS) -> mark# N, mark# snd X -> active# snd mark X) (active# head cons(N, XS) -> mark# N, mark# snd X -> snd# mark X) (active# head cons(N, XS) -> mark# N, mark# nil() -> active# nil()) (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> mark# X2) (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# 0() -> active# 0()) (active# head cons(N, XS) -> mark# N, mark# u(X1, X2, X3, X4) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4)) (active# head cons(N, XS) -> mark# N, mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4)) (active# head cons(N, XS) -> mark# N, mark# head X -> mark# X) (active# head cons(N, XS) -> mark# N, mark# head X -> active# head mark X) (active# head cons(N, XS) -> mark# N, mark# head X -> head# mark X) (active# head cons(N, XS) -> mark# N, mark# tail X -> mark# X) (active# head cons(N, XS) -> mark# N, mark# tail X -> active# tail mark X) (active# head cons(N, XS) -> mark# N, mark# tail X -> tail# mark X) (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> mark# X2) (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> mark# X2) (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> active# sel(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> sel#(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> mark# X1) (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> mark# X2) (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> active# take(mark X1, mark X2)) (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> take#(mark X1, mark X2)) (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(X1, mark X2) -> take#(X1, X2)) (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(X1, active X2) -> take#(X1, X2)) (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(mark X1, X2) -> take#(X1, X2)) (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(active X1, X2) -> take#(X1, X2)) (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2)) (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(X1, active X2) -> afterNth#(X1, X2)) (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2)) (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)) (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(X1, mark X2) -> pair#(X1, X2)) (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(X1, active X2) -> pair#(X1, X2)) (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(mark X1, X2) -> pair#(X1, X2)) (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(active X1, X2) -> pair#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS), pair#(X1, mark X2) -> pair#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS), pair#(X1, active X2) -> pair#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS), pair#(mark X1, X2) -> pair#(X1, X2)) (active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS), pair#(active X1, X2) -> pair#(X1, X2)) (take#(mark X1, X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (take#(mark X1, X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2)) (take#(mark X1, X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2)) (take#(mark X1, X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)) (take#(X1, mark X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2)) (take#(X1, mark X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2)) (take#(X1, mark X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2)) (take#(X1, mark X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)) (sel#(mark X1, X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2)) (sel#(mark X1, X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2)) (sel#(mark X1, X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2)) (sel#(mark X1, X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2)) (sel#(X1, mark X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2)) (sel#(X1, mark X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2)) (sel#(X1, mark X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2)) (sel#(X1, mark X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2)) (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2)) (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2)) (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2)) (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)) (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2)) (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2)) (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2)) (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)) (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2)) (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2)) (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2)) (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)) (pair#(mark X1, X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2)) (pair#(mark X1, X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2)) (pair#(mark X1, X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2)) (pair#(mark X1, X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)) (pair#(X1, mark X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2)) (pair#(X1, mark X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2)) (pair#(X1, mark X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2)) (pair#(X1, mark X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (cons#(mark X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2)) (cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2)) (cons#(X1, mark X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (cons#(X1, mark X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (mark# u(X1, X2, X3, X4) -> u#(mark X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)) (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(X1, mark X2) -> cons#(X1, X2)) (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(X1, active X2) -> cons#(X1, X2)) (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(mark X1, X2) -> cons#(X1, X2)) (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(active X1, X2) -> cons#(X1, X2)) (mark# head X -> head# mark X, head# mark X -> head# X) (mark# head X -> head# mark X, head# active X -> head# X) (mark# fst X -> fst# mark X, fst# mark X -> fst# X) (mark# fst X -> fst# mark X, fst# active X -> fst# X) (mark# natsFrom X -> natsFrom# mark X, natsFrom# mark X -> natsFrom# X) (mark# natsFrom X -> natsFrom# mark X, natsFrom# active X -> natsFrom# X) (mark# nil() -> active# nil(), active# natsFrom N -> mark# cons(N, natsFrom s N)) (mark# nil() -> active# nil(), active# natsFrom N -> cons#(N, natsFrom s N)) (mark# nil() -> active# nil(), active# natsFrom N -> natsFrom# s N) (mark# nil() -> active# nil(), active# natsFrom N -> s# N) (mark# nil() -> active# nil(), active# fst pair(XS, YS) -> mark# XS) (mark# nil() -> active# nil(), active# snd pair(XS, YS) -> mark# YS) (mark# nil() -> active# nil(), active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS)) (mark# nil() -> active# nil(), active# splitAt(s N, cons(X, XS)) -> splitAt#(N, XS)) (mark# nil() -> active# nil(), active# splitAt(s N, cons(X, XS)) -> u#(splitAt(N, XS), N, X, XS)) (mark# nil() -> active# nil(), active# splitAt(0(), XS) -> mark# pair(nil(), XS)) (mark# nil() -> active# nil(), active# splitAt(0(), XS) -> pair#(nil(), XS)) (mark# nil() -> active# nil(), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS)) (mark# nil() -> active# nil(), active# u(pair(YS, ZS), N, X, XS) -> cons#(X, YS)) (mark# nil() -> active# nil(), active# u(pair(YS, ZS), N, X, XS) -> pair#(cons(X, YS), ZS)) (mark# nil() -> active# nil(), active# head cons(N, XS) -> mark# N) (mark# nil() -> active# nil(), active# tail cons(N, XS) -> mark# XS) (mark# nil() -> active# nil(), active# afterNth(N, XS) -> mark# snd splitAt(N, XS)) (mark# nil() -> active# nil(), active# afterNth(N, XS) -> snd# splitAt(N, XS)) (mark# nil() -> active# nil(), active# afterNth(N, XS) -> splitAt#(N, XS)) (mark# nil() -> active# nil(), active# sel(N, XS) -> mark# head afterNth(N, XS)) (mark# nil() -> active# nil(), active# sel(N, XS) -> head# afterNth(N, XS)) (mark# nil() -> active# nil(), active# sel(N, XS) -> afterNth#(N, XS)) (mark# nil() -> active# nil(), active# take(N, XS) -> mark# fst splitAt(N, XS)) (mark# nil() -> active# nil(), active# take(N, XS) -> fst# splitAt(N, XS)) (mark# nil() -> active# nil(), active# take(N, XS) -> splitAt#(N, XS)) } STATUS: arrows: 0.852325 SCCS (14): Scc: { mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2), mark# natsFrom X -> mark# X, mark# natsFrom X -> active# natsFrom mark X, mark# s X -> mark# X, mark# s X -> active# s mark X, mark# fst X -> mark# X, mark# fst X -> active# fst mark X, mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2), mark# snd X -> mark# X, mark# snd X -> active# snd mark X, mark# nil() -> active# nil(), mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), mark# 0() -> active# 0(), mark# u(X1, X2, X3, X4) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), mark# head X -> mark# X, mark# head X -> active# head mark X, mark# tail X -> mark# X, mark# tail X -> active# tail mark X, mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2), mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N), active# fst pair(XS, YS) -> mark# XS, active# snd pair(XS, YS) -> mark# YS, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), active# splitAt(0(), XS) -> mark# pair(nil(), XS), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), active# head cons(N, XS) -> mark# N, active# tail cons(N, XS) -> mark# XS, active# afterNth(N, XS) -> mark# snd splitAt(N, XS), active# sel(N, XS) -> mark# head afterNth(N, XS), active# take(N, XS) -> mark# fst splitAt(N, XS)} Scc: { take#(X1, mark X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)} Scc: { sel#(X1, mark X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2)} Scc: { afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)} Scc: { tail# mark X -> tail# X, tail# active X -> tail# X} Scc: { head# mark X -> head# X, head# active X -> head# X} Scc: { splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)} Scc: { snd# mark X -> snd# X, snd# active X -> snd# X} Scc: { pair#(X1, mark X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)} Scc: { fst# mark X -> fst# X, fst# active X -> fst# X} Scc: { u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)} Scc: { s# mark X -> s# X, s# active X -> s# X} Scc: { natsFrom# mark X -> natsFrom# X, natsFrom# active X -> natsFrom# X} Scc: { cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2)} SCC (44): Strict: { mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2), mark# natsFrom X -> mark# X, mark# natsFrom X -> active# natsFrom mark X, mark# s X -> mark# X, mark# s X -> active# s mark X, mark# fst X -> mark# X, mark# fst X -> active# fst mark X, mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2), mark# snd X -> mark# X, mark# snd X -> active# snd mark X, mark# nil() -> active# nil(), mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), mark# 0() -> active# 0(), mark# u(X1, X2, X3, X4) -> mark# X1, mark# u(X1, X2, X3, X4) -> active# u(mark X1, X2, X3, X4), mark# head X -> mark# X, mark# head X -> active# head mark X, mark# tail X -> mark# X, mark# tail X -> active# tail mark X, mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2), mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N), active# fst pair(XS, YS) -> mark# XS, active# snd pair(XS, YS) -> mark# YS, active# splitAt(s N, cons(X, XS)) -> mark# u(splitAt(N, XS), N, X, XS), active# splitAt(0(), XS) -> mark# pair(nil(), XS), active# u(pair(YS, ZS), N, X, XS) -> mark# pair(cons(X, YS), ZS), active# head cons(N, XS) -> mark# N, active# tail cons(N, XS) -> mark# XS, active# afterNth(N, XS) -> mark# snd splitAt(N, XS), active# sel(N, XS) -> mark# head afterNth(N, XS), active# take(N, XS) -> mark# fst splitAt(N, XS)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (4): Strict: { take#(X1, mark X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (4): Strict: { sel#(X1, mark X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (4): Strict: { afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (2): Strict: { tail# mark X -> tail# X, tail# active X -> tail# X} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (2): Strict: { head# mark X -> head# X, head# active X -> head# X} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (4): Strict: { splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (2): Strict: { snd# mark X -> snd# X, snd# active X -> snd# X} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (4): Strict: { pair#(X1, mark X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (2): Strict: { fst# mark X -> fst# X, fst# active X -> fst# X} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (8): Strict: { u#(X1, X2, X3, mark X4) -> u#(X1, X2, X3, X4), u#(X1, X2, X3, active X4) -> u#(X1, X2, X3, X4), u#(X1, X2, mark X3, X4) -> u#(X1, X2, X3, X4), u#(X1, X2, active X3, X4) -> u#(X1, X2, X3, X4), u#(X1, mark X2, X3, X4) -> u#(X1, X2, X3, X4), u#(X1, active X2, X3, X4) -> u#(X1, X2, X3, X4), u#(mark X1, X2, X3, X4) -> u#(X1, X2, X3, X4), u#(active X1, X2, X3, X4) -> u#(X1, X2, X3, X4)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (2): Strict: { s# mark X -> s# X, s# active X -> s# X} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (2): Strict: { natsFrom# mark X -> natsFrom# X, natsFrom# active X -> natsFrom# X} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open SCC (4): Strict: { cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2)} Weak: { mark cons(X1, X2) -> active cons(mark X1, X2), mark natsFrom X -> active natsFrom mark X, mark s X -> active s mark X, mark fst X -> active fst mark X, mark pair(X1, X2) -> active pair(mark X1, mark X2), mark snd X -> active snd mark X, mark nil() -> active nil(), mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2), mark 0() -> active 0(), mark u(X1, X2, X3, X4) -> active u(mark X1, X2, X3, X4), mark head X -> active head mark X, mark tail X -> active tail mark X, mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2), mark sel(X1, X2) -> active sel(mark X1, mark X2), mark take(X1, X2) -> active take(mark X1, mark X2), cons(X1, mark X2) -> cons(X1, X2), cons(X1, active X2) -> cons(X1, X2), cons(mark X1, X2) -> cons(X1, X2), cons(active X1, X2) -> cons(X1, X2), natsFrom mark X -> natsFrom X, natsFrom active X -> natsFrom X, s mark X -> s X, s active X -> s X, active natsFrom N -> mark cons(N, natsFrom s N), active fst pair(XS, YS) -> mark XS, active snd pair(XS, YS) -> mark YS, active splitAt(s N, cons(X, XS)) -> mark u(splitAt(N, XS), N, X, XS), active splitAt(0(), XS) -> mark pair(nil(), XS), active u(pair(YS, ZS), N, X, XS) -> mark pair(cons(X, YS), ZS), active head cons(N, XS) -> mark N, active tail cons(N, XS) -> mark XS, active afterNth(N, XS) -> mark snd splitAt(N, XS), active sel(N, XS) -> mark head afterNth(N, XS), active take(N, XS) -> mark fst splitAt(N, XS), fst mark X -> fst X, fst active X -> fst X, pair(X1, mark X2) -> pair(X1, X2), pair(X1, active X2) -> pair(X1, X2), pair(mark X1, X2) -> pair(X1, X2), pair(active X1, X2) -> pair(X1, X2), snd mark X -> snd X, snd active X -> snd X, splitAt(X1, mark X2) -> splitAt(X1, X2), splitAt(X1, active X2) -> splitAt(X1, X2), splitAt(mark X1, X2) -> splitAt(X1, X2), splitAt(active X1, X2) -> splitAt(X1, X2), u(X1, X2, X3, mark X4) -> u(X1, X2, X3, X4), u(X1, X2, X3, active X4) -> u(X1, X2, X3, X4), u(X1, X2, mark X3, X4) -> u(X1, X2, X3, X4), u(X1, X2, active X3, X4) -> u(X1, X2, X3, X4), u(X1, mark X2, X3, X4) -> u(X1, X2, X3, X4), u(X1, active X2, X3, X4) -> u(X1, X2, X3, X4), u(mark X1, X2, X3, X4) -> u(X1, X2, X3, X4), u(active X1, X2, X3, X4) -> u(X1, X2, X3, X4), head mark X -> head X, head active X -> head X, tail mark X -> tail X, tail active X -> tail X, afterNth(X1, mark X2) -> afterNth(X1, X2), afterNth(X1, active X2) -> afterNth(X1, X2), afterNth(mark X1, X2) -> afterNth(X1, X2), afterNth(active X1, X2) -> afterNth(X1, X2), sel(X1, mark X2) -> sel(X1, X2), sel(X1, active X2) -> sel(X1, X2), sel(mark X1, X2) -> sel(X1, X2), sel(active X1, X2) -> sel(X1, X2), take(X1, mark X2) -> take(X1, X2), take(X1, active X2) -> take(X1, X2), take(mark X1, X2) -> take(X1, X2), take(active X1, X2) -> take(X1, X2)} Open