MAYBE
Time: 5.108837
TRS:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 DP:
  DP:
   {                U12#(mark X1, X2) -> U12#(X1, X2),
                   U12#(ok X1, ok X2) -> U12#(X1, X2),
                splitAt#(X1, mark X2) -> splitAt#(X1, X2),
                splitAt#(mark X1, X2) -> splitAt#(X1, X2),
               splitAt#(ok X1, ok X2) -> splitAt#(X1, X2),
                  active# U12(X1, X2) -> U12#(active X1, X2),
                  active# U12(X1, X2) -> active# X1,
         active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS),
         active# U12(pair(YS, ZS), X) -> cons#(X, YS),
              active# splitAt(X1, X2) -> splitAt#(X1, active X2),
              active# splitAt(X1, X2) -> splitAt#(active X1, X2),
              active# splitAt(X1, X2) -> active# X1,
              active# splitAt(X1, X2) -> active# X2,
    active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS),
             active# splitAt(0(), XS) -> pair#(nil(), XS),
          active# U11(X1, X2, X3, X4) -> active# X1,
          active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4),
          active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X),
          active# U11(tt(), N, X, XS) -> splitAt#(N, XS),
                 active# pair(X1, X2) -> active# X1,
                 active# pair(X1, X2) -> active# X2,
                 active# pair(X1, X2) -> pair#(X1, active X2),
                 active# pair(X1, X2) -> pair#(active X1, X2),
                 active# cons(X1, X2) -> active# X1,
                 active# cons(X1, X2) -> cons#(active X1, X2),
                        active# snd X -> active# X,
                        active# snd X -> snd# active X,
              active# afterNth(N, XS) -> splitAt#(N, XS),
              active# afterNth(N, XS) -> snd# splitAt(N, XS),
             active# afterNth(X1, X2) -> active# X1,
             active# afterNth(X1, X2) -> active# X2,
             active# afterNth(X1, X2) -> afterNth#(X1, active X2),
             active# afterNth(X1, X2) -> afterNth#(active X1, X2),
                  active# and(X1, X2) -> active# X1,
                  active# and(X1, X2) -> and#(active X1, X2),
                        active# fst X -> active# X,
                        active# fst X -> fst# active X,
                       active# head X -> active# X,
                       active# head X -> head# active X,
                   active# natsFrom N -> cons#(N, natsFrom s N),
                   active# natsFrom N -> natsFrom# s N,
                   active# natsFrom N -> s# N,
                   active# natsFrom X -> active# X,
                   active# natsFrom X -> natsFrom# active X,
                          active# s X -> active# X,
                          active# s X -> s# active X,
                   active# sel(N, XS) -> afterNth#(N, XS),
                   active# sel(N, XS) -> head# afterNth(N, XS),
                  active# sel(X1, X2) -> active# X1,
                  active# sel(X1, X2) -> active# X2,
                  active# sel(X1, X2) -> sel#(X1, active X2),
                  active# sel(X1, X2) -> sel#(active X1, X2),
                       active# tail X -> active# X,
                       active# tail X -> tail# active X,
                  active# take(N, XS) -> splitAt#(N, XS),
                  active# take(N, XS) -> fst# splitAt(N, XS),
                 active# take(X1, X2) -> active# X1,
                 active# take(X1, X2) -> active# X2,
                 active# take(X1, X2) -> take#(X1, active X2),
                 active# take(X1, X2) -> take#(active X1, X2),
            U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
     U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4),
                   pair#(X1, mark X2) -> pair#(X1, X2),
                   pair#(mark X1, X2) -> pair#(X1, X2),
                  pair#(ok X1, ok X2) -> pair#(X1, X2),
                   cons#(mark X1, X2) -> cons#(X1, X2),
                  cons#(ok X1, ok X2) -> cons#(X1, X2),
                          snd# mark X -> snd# X,
                            snd# ok X -> snd# X,
               afterNth#(X1, mark X2) -> afterNth#(X1, X2),
               afterNth#(mark X1, X2) -> afterNth#(X1, X2),
              afterNth#(ok X1, ok X2) -> afterNth#(X1, X2),
                    and#(mark X1, X2) -> and#(X1, X2),
                   and#(ok X1, ok X2) -> and#(X1, X2),
                          fst# mark X -> fst# X,
                            fst# ok X -> fst# X,
                         head# mark X -> head# X,
                           head# ok X -> head# X,
                     natsFrom# mark X -> natsFrom# X,
                       natsFrom# ok X -> natsFrom# X,
                            s# mark X -> s# X,
                              s# ok X -> s# X,
                    sel#(X1, mark X2) -> sel#(X1, X2),
                    sel#(mark X1, X2) -> sel#(X1, X2),
                   sel#(ok X1, ok X2) -> sel#(X1, X2),
                         tail# mark X -> tail# X,
                           tail# ok X -> tail# X,
                   take#(X1, mark X2) -> take#(X1, X2),
                   take#(mark X1, X2) -> take#(X1, X2),
                  take#(ok X1, ok X2) -> take#(X1, X2),
                  proper# U12(X1, X2) -> U12#(proper X1, proper X2),
                  proper# U12(X1, X2) -> proper# X1,
                  proper# U12(X1, X2) -> proper# X2,
              proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2),
              proper# splitAt(X1, X2) -> proper# X1,
              proper# splitAt(X1, X2) -> proper# X2,
          proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4),
          proper# U11(X1, X2, X3, X4) -> proper# X1,
          proper# U11(X1, X2, X3, X4) -> proper# X2,
          proper# U11(X1, X2, X3, X4) -> proper# X3,
          proper# U11(X1, X2, X3, X4) -> proper# X4,
                 proper# pair(X1, X2) -> pair#(proper X1, proper X2),
                 proper# pair(X1, X2) -> proper# X1,
                 proper# pair(X1, X2) -> proper# X2,
                 proper# cons(X1, X2) -> cons#(proper X1, proper X2),
                 proper# cons(X1, X2) -> proper# X1,
                 proper# cons(X1, X2) -> proper# X2,
                        proper# snd X -> snd# proper X,
                        proper# snd X -> proper# X,
             proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2),
             proper# afterNth(X1, X2) -> proper# X1,
             proper# afterNth(X1, X2) -> proper# X2,
                  proper# and(X1, X2) -> and#(proper X1, proper X2),
                  proper# and(X1, X2) -> proper# X1,
                  proper# and(X1, X2) -> proper# X2,
                        proper# fst X -> fst# proper X,
                        proper# fst X -> proper# X,
                       proper# head X -> head# proper X,
                       proper# head X -> proper# X,
                   proper# natsFrom X -> natsFrom# proper X,
                   proper# natsFrom X -> proper# X,
                          proper# s X -> s# proper X,
                          proper# s X -> proper# X,
                  proper# sel(X1, X2) -> sel#(proper X1, proper X2),
                  proper# sel(X1, X2) -> proper# X1,
                  proper# sel(X1, X2) -> proper# X2,
                       proper# tail X -> tail# proper X,
                       proper# tail X -> proper# X,
                 proper# take(X1, X2) -> take#(proper X1, proper X2),
                 proper# take(X1, X2) -> proper# X1,
                 proper# take(X1, X2) -> proper# X2,
                          top# mark X -> proper# X,
                          top# mark X -> top# proper X,
                            top# ok X -> active# X,
                            top# ok X -> top# active X}
  TRS:
  {                U12(mark X1, X2) -> mark U12(X1, X2),
                  U12(ok X1, ok X2) -> ok U12(X1, X2),
               splitAt(X1, mark X2) -> mark splitAt(X1, X2),
               splitAt(mark X1, X2) -> mark splitAt(X1, X2),
              splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                 active U12(X1, X2) -> U12(active X1, X2),
        active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
             active splitAt(X1, X2) -> splitAt(X1, active X2),
             active splitAt(X1, X2) -> splitAt(active X1, X2),
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
            active splitAt(0(), XS) -> mark pair(nil(), XS),
         active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                active pair(X1, X2) -> pair(X1, active X2),
                active pair(X1, X2) -> pair(active X1, X2),
                active cons(X1, X2) -> cons(active X1, X2),
                       active snd X -> snd active X,
              active snd pair(X, Y) -> mark Y,
             active afterNth(N, XS) -> mark snd splitAt(N, XS),
            active afterNth(X1, X2) -> afterNth(X1, active X2),
            active afterNth(X1, X2) -> afterNth(active X1, X2),
                 active and(X1, X2) -> and(active X1, X2),
                active and(tt(), X) -> mark X,
                       active fst X -> fst active X,
              active fst pair(X, Y) -> mark X,
                      active head X -> head active X,
            active head cons(N, XS) -> mark N,
                  active natsFrom N -> mark cons(N, natsFrom s N),
                  active natsFrom X -> natsFrom active X,
                         active s X -> s active X,
                  active sel(N, XS) -> mark head afterNth(N, XS),
                 active sel(X1, X2) -> sel(X1, active X2),
                 active sel(X1, X2) -> sel(active X1, X2),
                      active tail X -> tail active X,
            active tail cons(N, XS) -> mark XS,
                 active take(N, XS) -> mark fst splitAt(N, XS),
                active take(X1, X2) -> take(X1, active X2),
                active take(X1, X2) -> take(active X1, X2),
           U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                  pair(X1, mark X2) -> mark pair(X1, X2),
                  pair(mark X1, X2) -> mark pair(X1, X2),
                 pair(ok X1, ok X2) -> ok pair(X1, X2),
                  cons(mark X1, X2) -> mark cons(X1, X2),
                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                         snd mark X -> mark snd X,
                           snd ok X -> ok snd X,
              afterNth(X1, mark X2) -> mark afterNth(X1, X2),
              afterNth(mark X1, X2) -> mark afterNth(X1, X2),
             afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                   and(mark X1, X2) -> mark and(X1, X2),
                  and(ok X1, ok X2) -> ok and(X1, X2),
                         fst mark X -> mark fst X,
                           fst ok X -> ok fst X,
                        head mark X -> mark head X,
                          head ok X -> ok head X,
                    natsFrom mark X -> mark natsFrom X,
                      natsFrom ok X -> ok natsFrom X,
                           s mark X -> mark s X,
                             s ok X -> ok s X,
                   sel(X1, mark X2) -> mark sel(X1, X2),
                   sel(mark X1, X2) -> mark sel(X1, X2),
                  sel(ok X1, ok X2) -> ok sel(X1, X2),
                        tail mark X -> mark tail X,
                          tail ok X -> ok tail X,
                  take(X1, mark X2) -> mark take(X1, X2),
                  take(mark X1, X2) -> mark take(X1, X2),
                 take(ok X1, ok X2) -> ok take(X1, X2),
                 proper U12(X1, X2) -> U12(proper X1, proper X2),
             proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
         proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                        proper tt() -> ok tt(),
                proper pair(X1, X2) -> pair(proper X1, proper X2),
                proper cons(X1, X2) -> cons(proper X1, proper X2),
                       proper snd X -> snd proper X,
            proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                 proper and(X1, X2) -> and(proper X1, proper X2),
                       proper fst X -> fst proper X,
                      proper head X -> head proper X,
                  proper natsFrom X -> natsFrom proper X,
                         proper s X -> s proper X,
                 proper sel(X1, X2) -> sel(proper X1, proper X2),
                       proper nil() -> ok nil(),
                         proper 0() -> ok 0(),
                      proper tail X -> tail proper X,
                proper take(X1, X2) -> take(proper X1, proper X2),
                         top mark X -> top proper X,
                           top ok X -> top active X}
  UR:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                             a(x, y) -> x,
                             a(x, y) -> y}
   EDG:
    {
     (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
     (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
     (active# pair(X1, X2) -> active# X2, active# tail X -> tail# active X)
     (active# pair(X1, X2) -> active# X2, active# tail X -> active# X)
     (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
     (active# pair(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# pair(X1, X2) -> active# X2, active# s X -> active# X)
     (active# pair(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
     (active# pair(X1, X2) -> active# X2, active# natsFrom X -> active# X)
     (active# pair(X1, X2) -> active# X2, active# natsFrom N -> s# N)
     (active# pair(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
     (active# pair(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# pair(X1, X2) -> active# X2, active# head X -> head# active X)
     (active# pair(X1, X2) -> active# X2, active# head X -> active# X)
     (active# pair(X1, X2) -> active# X2, active# fst X -> fst# active X)
     (active# pair(X1, X2) -> active# X2, active# fst X -> active# X)
     (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# pair(X1, X2) -> active# X2, active# snd X -> snd# active X)
     (active# pair(X1, X2) -> active# X2, active# snd X -> active# X)
     (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# pair(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
     (active# sel(X1, X2) -> active# X2, active# tail X -> tail# active X)
     (active# sel(X1, X2) -> active# X2, active# tail X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
     (active# sel(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# sel(X1, X2) -> active# X2, active# s X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
     (active# sel(X1, X2) -> active# X2, active# natsFrom X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# natsFrom N -> s# N)
     (active# sel(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
     (active# sel(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# sel(X1, X2) -> active# X2, active# head X -> head# active X)
     (active# sel(X1, X2) -> active# X2, active# head X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# fst X -> fst# active X)
     (active# sel(X1, X2) -> active# X2, active# fst X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# sel(X1, X2) -> active# X2, active# snd X -> snd# active X)
     (active# sel(X1, X2) -> active# X2, active# snd X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# sel(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
     (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# U12(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# U12(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# U12(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# U12(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# U12(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# U12(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# U12(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> s# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> head# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# take(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# take(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# take(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# take(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# take(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# take(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# take(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (active# U12(X1, X2) -> U12#(active X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
     (active# U12(X1, X2) -> U12#(active X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
     (active# pair(X1, X2) -> pair#(active X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
     (active# pair(X1, X2) -> pair#(active X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
     (active# pair(X1, X2) -> pair#(active X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
     (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
     (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
     (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
     (active# sel(X1, X2) -> sel#(active X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (active# sel(X1, X2) -> sel#(active X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (active# sel(X1, X2) -> sel#(active X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(ok X1, ok X2) -> pair#(X1, X2))
     (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(mark X1, X2) -> pair#(X1, X2))
     (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(X1, mark X2) -> pair#(X1, X2))
     (U12#(mark X1, X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
     (U12#(mark X1, X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
     (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
     (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
     (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
     (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
     (pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(X1, mark X2) -> pair#(X1, X2))
     (cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok 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#(X1, mark X2) -> afterNth#(X1, X2))
     (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
     (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
     (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
     (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
     (sel#(mark X1, X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(X1, mark X2) -> sel#(X1, X2))
     (take#(X1, mark X2) -> take#(X1, X2), take#(ok X1, ok 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#(X1, mark X2) -> take#(X1, X2))
     (take#(ok X1, ok X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
     (take#(ok X1, ok X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2))
     (take#(ok X1, ok X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
     (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
     (active# take(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# splitAt(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# splitAt(X1, X2) -> active# X1, active# s X -> active# X)
     (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# splitAt(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# splitAt(X1, X2) -> active# X1, active# head X -> active# X)
     (active# splitAt(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# splitAt(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# splitAt(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# splitAt(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# pair(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# pair(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# pair(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# pair(X1, X2) -> active# X1, active# s X -> active# X)
     (active# pair(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# pair(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# pair(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# pair(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# pair(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# pair(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# pair(X1, X2) -> active# X1, active# head X -> active# X)
     (active# pair(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# pair(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# pair(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# pair(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# pair(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# ok X -> snd# X)
     (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# mark X -> snd# X)
     (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# and(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# and(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# and(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# and(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# and(X1, X2) -> active# X1, active# s X -> active# X)
     (active# and(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# and(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# and(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# and(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# and(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# and(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# and(X1, X2) -> active# X1, active# head X -> active# X)
     (active# and(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# and(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# and(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# and(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# and(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# sel(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# sel(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# sel(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# sel(X1, X2) -> active# X1, active# s X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# sel(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# sel(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# sel(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# sel(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# sel(X1, X2) -> active# X1, active# head X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# sel(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# sel(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# sel(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# sel(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# take(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# take(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# take(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# take(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# take(X1, X2) -> active# X1, active# s X -> active# X)
     (active# take(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# take(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# take(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# take(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# take(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# take(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# take(X1, X2) -> active# X1, active# head X -> active# X)
     (active# take(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# take(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# take(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# take(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# take(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# pair(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# pair(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# pair(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# pair(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# pair(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# pair(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# pair(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> tail# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> s# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> natsFrom# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> head# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> fst# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> snd# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (active# pair(X1, X2) -> pair#(X1, active X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
     (active# pair(X1, X2) -> pair#(X1, active X2), pair#(mark X1, X2) -> pair#(X1, X2))
     (active# pair(X1, X2) -> pair#(X1, active X2), pair#(X1, mark X2) -> pair#(X1, X2))
     (active# sel(X1, X2) -> sel#(X1, active X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (active# sel(X1, X2) -> sel#(X1, active X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (active# sel(X1, X2) -> sel#(X1, active X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
     (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(mark X1, X2) -> U12#(X1, X2))
     (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
     (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(mark X1, X2) -> pair#(X1, X2))
     (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(X1, mark X2) -> pair#(X1, X2))
     (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
     (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
     (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
     (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (active# snd X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (active# snd X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (active# snd X -> active# X, active# take(X1, X2) -> active# X2)
     (active# snd X -> active# X, active# take(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# snd X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (active# snd X -> active# X, active# tail X -> tail# active X)
     (active# snd X -> active# X, active# tail X -> active# X)
     (active# snd X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# snd X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# snd X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# snd X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# snd X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (active# snd X -> active# X, active# s X -> s# active X)
     (active# snd X -> active# X, active# s X -> active# X)
     (active# snd X -> active# X, active# natsFrom X -> natsFrom# active X)
     (active# snd X -> active# X, active# natsFrom X -> active# X)
     (active# snd X -> active# X, active# natsFrom N -> s# N)
     (active# snd X -> active# X, active# natsFrom N -> natsFrom# s N)
     (active# snd X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# snd X -> active# X, active# head X -> head# active X)
     (active# snd X -> active# X, active# head X -> active# X)
     (active# snd X -> active# X, active# fst X -> fst# active X)
     (active# snd X -> active# X, active# fst X -> active# X)
     (active# snd X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (active# snd X -> active# X, active# and(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# snd X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# snd X -> active# X, active# snd X -> snd# active X)
     (active# snd X -> active# X, active# snd X -> active# X)
     (active# snd X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# snd X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# snd X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# snd X -> active# X, active# pair(X1, X2) -> active# X2)
     (active# snd X -> active# X, active# pair(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# snd X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# snd X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# snd X -> active# X, active# U12(X1, X2) -> active# X1)
     (active# snd X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# head X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (active# head X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (active# head X -> active# X, active# take(X1, X2) -> active# X2)
     (active# head X -> active# X, active# take(X1, X2) -> active# X1)
     (active# head X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# head X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (active# head X -> active# X, active# tail X -> tail# active X)
     (active# head X -> active# X, active# tail X -> active# X)
     (active# head X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# head X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# head X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# head X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# head X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# head X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (active# head X -> active# X, active# s X -> s# active X)
     (active# head X -> active# X, active# s X -> active# X)
     (active# head X -> active# X, active# natsFrom X -> natsFrom# active X)
     (active# head X -> active# X, active# natsFrom X -> active# X)
     (active# head X -> active# X, active# natsFrom N -> s# N)
     (active# head X -> active# X, active# natsFrom N -> natsFrom# s N)
     (active# head X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# head X -> active# X, active# head X -> head# active X)
     (active# head X -> active# X, active# head X -> active# X)
     (active# head X -> active# X, active# fst X -> fst# active X)
     (active# head X -> active# X, active# fst X -> active# X)
     (active# head X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (active# head X -> active# X, active# and(X1, X2) -> active# X1)
     (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# head X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (active# head X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (active# head X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# head X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# head X -> active# X, active# snd X -> snd# active X)
     (active# head X -> active# X, active# snd X -> active# X)
     (active# head X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# head X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# head X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# head X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# head X -> active# X, active# pair(X1, X2) -> active# X2)
     (active# head X -> active# X, active# pair(X1, X2) -> active# X1)
     (active# head X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# head X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# head X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# head X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# head X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (active# head X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# head X -> active# X, active# U12(X1, X2) -> active# X1)
     (active# head X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# s X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (active# s X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (active# s X -> active# X, active# take(X1, X2) -> active# X2)
     (active# s X -> active# X, active# take(X1, X2) -> active# X1)
     (active# s X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# s X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (active# s X -> active# X, active# tail X -> tail# active X)
     (active# s X -> active# X, active# tail X -> active# X)
     (active# s X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# s X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# s X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# s X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# s X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# s X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (active# s X -> active# X, active# s X -> s# active X)
     (active# s X -> active# X, active# s X -> active# X)
     (active# s X -> active# X, active# natsFrom X -> natsFrom# active X)
     (active# s X -> active# X, active# natsFrom X -> active# X)
     (active# s X -> active# X, active# natsFrom N -> s# N)
     (active# s X -> active# X, active# natsFrom N -> natsFrom# s N)
     (active# s X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# s X -> active# X, active# head X -> head# active X)
     (active# s X -> active# X, active# head X -> active# X)
     (active# s X -> active# X, active# fst X -> fst# active X)
     (active# s X -> active# X, active# fst X -> active# X)
     (active# s X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (active# s X -> active# X, active# and(X1, X2) -> active# X1)
     (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# s X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (active# s X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (active# s X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# s X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# s X -> active# X, active# snd X -> snd# active X)
     (active# s X -> active# X, active# snd X -> active# X)
     (active# s X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# s X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# s X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# s X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# s X -> active# X, active# pair(X1, X2) -> active# X2)
     (active# s X -> active# X, active# pair(X1, X2) -> active# X1)
     (active# s X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# s X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# s X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# s X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# s X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (active# s X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# s X -> active# X, active# U12(X1, X2) -> active# X1)
     (active# s X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (snd# mark X -> snd# X, snd# ok X -> snd# X)
     (snd# mark X -> snd# X, snd# mark X -> snd# X)
     (fst# mark X -> fst# X, fst# ok X -> fst# X)
     (fst# mark X -> fst# X, fst# mark X -> fst# X)
     (head# mark X -> head# X, head# ok X -> head# X)
     (head# mark X -> head# X, head# mark X -> head# X)
     (natsFrom# mark X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
     (natsFrom# mark X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
     (s# mark X -> s# X, s# ok X -> s# X)
     (s# mark X -> s# X, s# mark X -> s# X)
     (tail# mark X -> tail# X, tail# ok X -> tail# X)
     (tail# mark X -> tail# X, tail# mark X -> tail# X)
     (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# tail X -> proper# X)
     (proper# snd X -> proper# X, proper# tail X -> tail# proper X)
     (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# s X -> proper# X)
     (proper# snd X -> proper# X, proper# s X -> s# proper X)
     (proper# snd X -> proper# X, proper# natsFrom X -> proper# X)
     (proper# snd X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (proper# snd X -> proper# X, proper# head X -> proper# X)
     (proper# snd X -> proper# X, proper# head X -> head# proper X)
     (proper# snd X -> proper# X, proper# fst X -> proper# X)
     (proper# snd X -> proper# X, proper# fst X -> fst# proper X)
     (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# snd X -> proper# X)
     (proper# snd X -> proper# X, proper# snd X -> snd# proper X)
     (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (proper# snd X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# tail X -> proper# X)
     (proper# head X -> proper# X, proper# tail X -> tail# proper X)
     (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# s X -> proper# X)
     (proper# head X -> proper# X, proper# s X -> s# proper X)
     (proper# head X -> proper# X, proper# natsFrom X -> proper# X)
     (proper# head X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (proper# head X -> proper# X, proper# head X -> proper# X)
     (proper# head X -> proper# X, proper# head X -> head# proper X)
     (proper# head X -> proper# X, proper# fst X -> proper# X)
     (proper# head X -> proper# X, proper# fst X -> fst# proper X)
     (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# snd X -> proper# X)
     (proper# head X -> proper# X, proper# snd X -> snd# proper X)
     (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (proper# head X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# tail X -> proper# X)
     (proper# s X -> proper# X, proper# tail X -> tail# proper X)
     (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# s X -> proper# X)
     (proper# s X -> proper# X, proper# s X -> s# proper X)
     (proper# s X -> proper# X, proper# natsFrom X -> proper# X)
     (proper# s X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (proper# s X -> proper# X, proper# head X -> proper# X)
     (proper# s X -> proper# X, proper# head X -> head# proper X)
     (proper# s X -> proper# X, proper# fst X -> proper# X)
     (proper# s X -> proper# X, proper# fst X -> fst# proper X)
     (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# snd X -> proper# X)
     (proper# s X -> proper# X, proper# snd X -> snd# proper X)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# tail X -> proper# X)
     (top# mark X -> proper# X, proper# tail X -> tail# proper X)
     (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# s X -> proper# X)
     (top# mark X -> proper# X, proper# s X -> s# proper X)
     (top# mark X -> proper# X, proper# natsFrom X -> proper# X)
     (top# mark X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (top# mark X -> proper# X, proper# head X -> proper# X)
     (top# mark X -> proper# X, proper# head X -> head# proper X)
     (top# mark X -> proper# X, proper# fst X -> proper# X)
     (top# mark X -> proper# X, proper# fst X -> fst# proper X)
     (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# snd X -> proper# X)
     (top# mark X -> proper# X, proper# snd X -> snd# proper X)
     (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (active# snd X -> snd# active X, snd# ok X -> snd# X)
     (active# snd X -> snd# active X, snd# mark X -> snd# X)
     (active# head X -> head# active X, head# ok X -> head# X)
     (active# head X -> head# active X, head# mark X -> head# X)
     (active# s X -> s# active X, s# ok X -> s# X)
     (active# s X -> s# active X, s# mark X -> s# X)
     (proper# snd X -> snd# proper X, snd# ok X -> snd# X)
     (proper# snd X -> snd# proper X, snd# mark X -> snd# X)
     (proper# head X -> head# proper X, head# ok X -> head# X)
     (proper# head X -> head# proper X, head# mark X -> head# X)
     (proper# s X -> s# proper X, s# ok X -> s# X)
     (proper# s X -> s# proper X, s# mark X -> s# X)
     (top# mark X -> top# proper X, top# ok X -> top# active X)
     (top# mark X -> top# proper X, top# ok X -> active# X)
     (top# mark X -> top# proper X, top# mark X -> top# proper X)
     (top# mark X -> top# proper X, top# mark X -> proper# X)
     (active# natsFrom N -> natsFrom# s N, natsFrom# ok X -> natsFrom# X)
     (active# natsFrom N -> natsFrom# s N, natsFrom# mark X -> natsFrom# X)
     (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(mark X1, X2) -> cons#(X1, X2))
     (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(ok X1, ok X2) -> U12#(X1, X2))
     (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(mark X1, X2) -> U12#(X1, X2))
     (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
     (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
     (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(ok X1, ok 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#(X1, mark X2) -> pair#(X1, X2))
     (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
     (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
     (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
     (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
     (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
     (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> snd# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> fst# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> head# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> natsFrom# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> s# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> tail# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
     (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
     (top# ok X -> top# active X, top# mark X -> proper# X)
     (top# ok X -> top# active X, top# mark X -> top# proper X)
     (top# ok X -> top# active X, top# ok X -> active# X)
     (top# ok X -> top# active X, top# ok X -> top# active X)
     (proper# tail X -> tail# proper X, tail# mark X -> tail# X)
     (proper# tail X -> tail# proper X, tail# ok X -> tail# X)
     (proper# natsFrom X -> natsFrom# proper X, natsFrom# mark X -> natsFrom# X)
     (proper# natsFrom X -> natsFrom# proper X, natsFrom# ok X -> natsFrom# X)
     (proper# fst X -> fst# proper X, fst# mark X -> fst# X)
     (proper# fst X -> fst# proper X, fst# ok X -> fst# X)
     (active# tail X -> tail# active X, tail# mark X -> tail# X)
     (active# tail X -> tail# active X, tail# ok X -> tail# X)
     (active# natsFrom X -> natsFrom# active X, natsFrom# mark X -> natsFrom# X)
     (active# natsFrom X -> natsFrom# active X, natsFrom# ok X -> natsFrom# X)
     (active# fst X -> fst# active X, fst# mark X -> fst# X)
     (active# fst X -> fst# active X, fst# ok X -> fst# X)
     (top# ok X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (top# ok X -> active# X, active# U12(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (top# ok X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (top# ok X -> active# X, active# pair(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# pair(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (top# ok X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (top# ok X -> active# X, active# cons(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (top# ok X -> active# X, active# snd X -> active# X)
     (top# ok X -> active# X, active# snd X -> snd# active X)
     (top# ok X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (top# ok X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (top# ok X -> active# X, active# fst X -> active# X)
     (top# ok X -> active# X, active# fst X -> fst# active X)
     (top# ok X -> active# X, active# head X -> active# X)
     (top# ok X -> active# X, active# head X -> head# active X)
     (top# ok X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (top# ok X -> active# X, active# natsFrom N -> natsFrom# s N)
     (top# ok X -> active# X, active# natsFrom N -> s# N)
     (top# ok X -> active# X, active# natsFrom X -> active# X)
     (top# ok X -> active# X, active# natsFrom X -> natsFrom# active X)
     (top# ok X -> active# X, active# s X -> active# X)
     (top# ok X -> active# X, active# s X -> s# active X)
     (top# ok X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (top# ok X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (top# ok X -> active# X, active# sel(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# sel(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (top# ok X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (top# ok X -> active# X, active# tail X -> active# X)
     (top# ok X -> active# X, active# tail X -> tail# active X)
     (top# ok X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (top# ok X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (top# ok X -> active# X, active# take(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# take(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (top# ok X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (proper# tail X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# tail X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# snd X -> snd# proper X)
     (proper# tail X -> proper# X, proper# snd X -> proper# X)
     (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# fst X -> fst# proper X)
     (proper# tail X -> proper# X, proper# fst X -> proper# X)
     (proper# tail X -> proper# X, proper# head X -> head# proper X)
     (proper# tail X -> proper# X, proper# head X -> proper# X)
     (proper# tail X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (proper# tail X -> proper# X, proper# natsFrom X -> proper# X)
     (proper# tail X -> proper# X, proper# s X -> s# proper X)
     (proper# tail X -> proper# X, proper# s X -> proper# X)
     (proper# tail X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# tail X -> proper# X, proper# tail X -> tail# proper X)
     (proper# tail X -> proper# X, proper# tail X -> proper# X)
     (proper# tail X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# snd X -> snd# proper X)
     (proper# natsFrom X -> proper# X, proper# snd X -> proper# X)
     (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# fst X -> fst# proper X)
     (proper# natsFrom X -> proper# X, proper# fst X -> proper# X)
     (proper# natsFrom X -> proper# X, proper# head X -> head# proper X)
     (proper# natsFrom X -> proper# X, proper# head X -> proper# X)
     (proper# natsFrom X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (proper# natsFrom X -> proper# X, proper# natsFrom X -> proper# X)
     (proper# natsFrom X -> proper# X, proper# s X -> s# proper X)
     (proper# natsFrom X -> proper# X, proper# s X -> proper# X)
     (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# natsFrom X -> proper# X, proper# tail X -> tail# proper X)
     (proper# natsFrom X -> proper# X, proper# tail X -> proper# X)
     (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# fst X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# snd X -> snd# proper X)
     (proper# fst X -> proper# X, proper# snd X -> proper# X)
     (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# fst X -> fst# proper X)
     (proper# fst X -> proper# X, proper# fst X -> proper# X)
     (proper# fst X -> proper# X, proper# head X -> head# proper X)
     (proper# fst X -> proper# X, proper# head X -> proper# X)
     (proper# fst X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
     (proper# fst X -> proper# X, proper# natsFrom X -> proper# X)
     (proper# fst X -> proper# X, proper# s X -> s# proper X)
     (proper# fst X -> proper# X, proper# s X -> proper# X)
     (proper# fst X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# fst X -> proper# X, proper# tail X -> tail# proper X)
     (proper# fst X -> proper# X, proper# tail X -> proper# X)
     (proper# fst X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X1)
     (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X2)
     (tail# ok X -> tail# X, tail# mark X -> tail# X)
     (tail# ok X -> tail# X, tail# ok X -> tail# X)
     (s# ok X -> s# X, s# mark X -> s# X)
     (s# ok X -> s# X, s# ok X -> s# X)
     (natsFrom# ok X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
     (natsFrom# ok X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
     (head# ok X -> head# X, head# mark X -> head# X)
     (head# ok X -> head# X, head# ok X -> head# X)
     (fst# ok X -> fst# X, fst# mark X -> fst# X)
     (fst# ok X -> fst# X, fst# ok X -> fst# X)
     (snd# ok X -> snd# X, snd# mark X -> snd# X)
     (snd# ok X -> snd# X, snd# ok X -> snd# X)
     (active# tail X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# tail X -> active# X, active# U12(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (active# tail X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# tail X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# tail X -> active# X, active# pair(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# pair(X1, X2) -> active# X2)
     (active# tail X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# tail X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# tail X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# tail X -> active# X, active# snd X -> active# X)
     (active# tail X -> active# X, active# snd X -> snd# active X)
     (active# tail X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# tail X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# tail X -> active# X, active# and(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (active# tail X -> active# X, active# fst X -> active# X)
     (active# tail X -> active# X, active# fst X -> fst# active X)
     (active# tail X -> active# X, active# head X -> active# X)
     (active# tail X -> active# X, active# head X -> head# active X)
     (active# tail X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# tail X -> active# X, active# natsFrom N -> natsFrom# s N)
     (active# tail X -> active# X, active# natsFrom N -> s# N)
     (active# tail X -> active# X, active# natsFrom X -> active# X)
     (active# tail X -> active# X, active# natsFrom X -> natsFrom# active X)
     (active# tail X -> active# X, active# s X -> active# X)
     (active# tail X -> active# X, active# s X -> s# active X)
     (active# tail X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (active# tail X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# tail X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# tail X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# tail X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# tail X -> active# X, active# tail X -> active# X)
     (active# tail X -> active# X, active# tail X -> tail# active X)
     (active# tail X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (active# tail X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# tail X -> active# X, active# take(X1, X2) -> active# X1)
     (active# tail X -> active# X, active# take(X1, X2) -> active# X2)
     (active# tail X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (active# tail X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (active# natsFrom X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# natsFrom X -> active# X, active# U12(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (active# natsFrom X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# natsFrom X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X2)
     (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# natsFrom X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# natsFrom X -> active# X, active# snd X -> active# X)
     (active# natsFrom X -> active# X, active# snd X -> snd# active X)
     (active# natsFrom X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# natsFrom X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# natsFrom X -> active# X, active# and(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (active# natsFrom X -> active# X, active# fst X -> active# X)
     (active# natsFrom X -> active# X, active# fst X -> fst# active X)
     (active# natsFrom X -> active# X, active# head X -> active# X)
     (active# natsFrom X -> active# X, active# head X -> head# active X)
     (active# natsFrom X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# natsFrom X -> active# X, active# natsFrom N -> natsFrom# s N)
     (active# natsFrom X -> active# X, active# natsFrom N -> s# N)
     (active# natsFrom X -> active# X, active# natsFrom X -> active# X)
     (active# natsFrom X -> active# X, active# natsFrom X -> natsFrom# active X)
     (active# natsFrom X -> active# X, active# s X -> active# X)
     (active# natsFrom X -> active# X, active# s X -> s# active X)
     (active# natsFrom X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (active# natsFrom X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# natsFrom X -> active# X, active# tail X -> active# X)
     (active# natsFrom X -> active# X, active# tail X -> tail# active X)
     (active# natsFrom X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (active# natsFrom X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X1)
     (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X2)
     (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (active# fst X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# fst X -> active# X, active# U12(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X2)
     (active# fst X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# fst X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# fst X -> active# X, active# pair(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# pair(X1, X2) -> active# X2)
     (active# fst X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# fst X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# fst X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# fst X -> active# X, active# snd X -> active# X)
     (active# fst X -> active# X, active# snd X -> snd# active X)
     (active# fst X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# fst X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X2)
     (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# fst X -> active# X, active# and(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (active# fst X -> active# X, active# fst X -> active# X)
     (active# fst X -> active# X, active# fst X -> fst# active X)
     (active# fst X -> active# X, active# head X -> active# X)
     (active# fst X -> active# X, active# head X -> head# active X)
     (active# fst X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# fst X -> active# X, active# natsFrom N -> natsFrom# s N)
     (active# fst X -> active# X, active# natsFrom N -> s# N)
     (active# fst X -> active# X, active# natsFrom X -> active# X)
     (active# fst X -> active# X, active# natsFrom X -> natsFrom# active X)
     (active# fst X -> active# X, active# s X -> active# X)
     (active# fst X -> active# X, active# s X -> s# active X)
     (active# fst X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
     (active# fst X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# fst X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# fst X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# fst X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# fst X -> active# X, active# tail X -> active# X)
     (active# fst X -> active# X, active# tail X -> tail# active X)
     (active# fst X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
     (active# fst X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# fst X -> active# X, active# take(X1, X2) -> active# X1)
     (active# fst X -> active# X, active# take(X1, X2) -> active# X2)
     (active# fst X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
     (active# fst X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
     (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(X1, mark X2) -> take#(X1, X2))
     (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(mark X1, X2) -> take#(X1, X2))
     (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(ok X1, ok X2) -> take#(X1, X2))
     (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
     (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
     (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
     (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
     (active# take(X1, X2) -> take#(X1, active X2), take#(X1, mark X2) -> take#(X1, X2))
     (active# take(X1, X2) -> take#(X1, active X2), take#(mark X1, X2) -> take#(X1, X2))
     (active# take(X1, X2) -> take#(X1, active X2), take#(ok X1, ok X2) -> take#(X1, X2))
     (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
     (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
     (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
     (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
     (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
     (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
     (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# take(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# take(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# take(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# take(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# take(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# take(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# take(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# take(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> head# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> s# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> proper# X)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
     (proper# U12(X1, X2) -> proper# X1, proper# snd X -> proper# X)
     (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
     (proper# U12(X1, X2) -> proper# X1, proper# fst X -> proper# X)
     (proper# U12(X1, X2) -> proper# X1, proper# head X -> head# proper X)
     (proper# U12(X1, X2) -> proper# X1, proper# head X -> proper# X)
     (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
     (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
     (proper# U12(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# U12(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# U12(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
     (proper# U12(X1, X2) -> proper# X1, proper# tail X -> proper# X)
     (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
     (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
     (active# take(N, XS) -> fst# splitAt(N, XS), fst# mark X -> fst# X)
     (active# take(N, XS) -> fst# splitAt(N, XS), fst# ok X -> fst# X)
     (active# sel(N, XS) -> head# afterNth(N, XS), head# mark X -> head# X)
     (active# sel(N, XS) -> head# afterNth(N, XS), head# ok X -> head# X)
     (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# afterNth(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# afterNth(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# afterNth(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# afterNth(X1, X2) -> active# X1, active# head X -> active# X)
     (active# afterNth(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# afterNth(X1, X2) -> active# X1, active# s X -> active# X)
     (active# afterNth(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# afterNth(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# cons(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# cons(X1, X2) -> active# X1, active# head X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# cons(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# cons(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# cons(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# cons(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# cons(X1, X2) -> active# X1, active# s X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> active# X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> snd# active X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> active# X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> fst# active X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> active# X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> head# active X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> s# N)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> active# X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> active# X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> s# active X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> active# X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> tail# active X)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
     (active# U12(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# U12(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
     (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# snd X -> active# X)
     (active# U12(X1, X2) -> active# X1, active# snd X -> snd# active X)
     (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
     (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# fst X -> active# X)
     (active# U12(X1, X2) -> active# X1, active# fst X -> fst# active X)
     (active# U12(X1, X2) -> active# X1, active# head X -> active# X)
     (active# U12(X1, X2) -> active# X1, active# head X -> head# active X)
     (active# U12(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# U12(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
     (active# U12(X1, X2) -> active# X1, active# natsFrom N -> s# N)
     (active# U12(X1, X2) -> active# X1, active# natsFrom X -> active# X)
     (active# U12(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
     (active# U12(X1, X2) -> active# X1, active# s X -> active# X)
     (active# U12(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
     (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# U12(X1, X2) -> active# X1, active# tail X -> active# X)
     (active# U12(X1, X2) -> active# X1, active# tail X -> tail# active X)
     (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
     (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
     (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
     (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
     (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
     (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
     (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
     (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
     (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
     (take#(mark X1, X2) -> take#(X1, X2), take#(X1, mark 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#(ok X1, ok X2) -> take#(X1, X2))
     (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(mark X1, X2) -> sel#(X1, X2))
     (sel#(X1, mark X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
     (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
     (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
     (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
     (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(mark X1, X2) -> pair#(X1, X2))
     (pair#(X1, mark X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
     (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark 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#(ok X1, ok X2) -> splitAt#(X1, X2))
     (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
     (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(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#(ok X1, ok X2) -> cons#(X1, X2))
     (active# take(X1, X2) -> take#(active X1, X2), take#(X1, mark X2) -> take#(X1, X2))
     (active# take(X1, X2) -> take#(active X1, X2), take#(mark X1, X2) -> take#(X1, X2))
     (active# take(X1, X2) -> take#(active X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
     (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
     (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (active# cons(X1, X2) -> cons#(active X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (active# cons(X1, X2) -> cons#(active X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
     (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
     (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
     (active# natsFrom N -> s# N, s# mark X -> s# X)
     (active# natsFrom N -> s# N, s# ok X -> s# X)
     (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# pair(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# pair(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# pair(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# pair(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# pair(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# pair(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# pair(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
     (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
     (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
     (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> head# proper X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> proper# X)
     (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
     (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
     (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
     (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# take(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# snd X -> active# X)
     (active# take(X1, X2) -> active# X2, active# snd X -> snd# active X)
     (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# fst X -> active# X)
     (active# take(X1, X2) -> active# X2, active# fst X -> fst# active X)
     (active# take(X1, X2) -> active# X2, active# head X -> active# X)
     (active# take(X1, X2) -> active# X2, active# head X -> head# active X)
     (active# take(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# take(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
     (active# take(X1, X2) -> active# X2, active# natsFrom N -> s# N)
     (active# take(X1, X2) -> active# X2, active# natsFrom X -> active# X)
     (active# take(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
     (active# take(X1, X2) -> active# X2, active# s X -> active# X)
     (active# take(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
     (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# take(X1, X2) -> active# X2, active# tail X -> active# X)
     (active# take(X1, X2) -> active# X2, active# tail X -> tail# active X)
     (active# take(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
     (active# take(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
     (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
     (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
     (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# afterNth(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# snd X -> active# X)
     (active# afterNth(X1, X2) -> active# X2, active# snd X -> snd# active X)
     (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# fst X -> active# X)
     (active# afterNth(X1, X2) -> active# X2, active# fst X -> fst# active X)
     (active# afterNth(X1, X2) -> active# X2, active# head X -> active# X)
     (active# afterNth(X1, X2) -> active# X2, active# head X -> head# active X)
     (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
     (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> s# N)
     (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> active# X)
     (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
     (active# afterNth(X1, X2) -> active# X2, active# s X -> active# X)
     (active# afterNth(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# afterNth(X1, X2) -> active# X2, active# tail X -> active# X)
     (active# afterNth(X1, X2) -> active# X2, active# tail X -> tail# active X)
     (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
     (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
     (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
     (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
     (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
     (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
     (active# splitAt(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
     (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
     (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
     (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# snd X -> active# X)
     (active# splitAt(X1, X2) -> active# X2, active# snd X -> snd# active X)
     (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# fst X -> active# X)
     (active# splitAt(X1, X2) -> active# X2, active# fst X -> fst# active X)
     (active# splitAt(X1, X2) -> active# X2, active# head X -> active# X)
     (active# splitAt(X1, X2) -> active# X2, active# head X -> head# active X)
     (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
     (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
     (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> s# N)
     (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> active# X)
     (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
     (active# splitAt(X1, X2) -> active# X2, active# s X -> active# X)
     (active# splitAt(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# splitAt(X1, X2) -> active# X2, active# tail X -> active# X)
     (active# splitAt(X1, X2) -> active# X2, active# tail X -> tail# active X)
     (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
     (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
     (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
     (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
     (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
    }
    EDG:
     {
      (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
      (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
      (active# pair(X1, X2) -> active# X2, active# tail X -> tail# active X)
      (active# pair(X1, X2) -> active# X2, active# tail X -> active# X)
      (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
      (active# pair(X1, X2) -> active# X2, active# s X -> s# active X)
      (active# pair(X1, X2) -> active# X2, active# s X -> active# X)
      (active# pair(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
      (active# pair(X1, X2) -> active# X2, active# natsFrom X -> active# X)
      (active# pair(X1, X2) -> active# X2, active# natsFrom N -> s# N)
      (active# pair(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
      (active# pair(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# pair(X1, X2) -> active# X2, active# head X -> head# active X)
      (active# pair(X1, X2) -> active# X2, active# head X -> active# X)
      (active# pair(X1, X2) -> active# X2, active# fst X -> fst# active X)
      (active# pair(X1, X2) -> active# X2, active# fst X -> active# X)
      (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# pair(X1, X2) -> active# X2, active# snd X -> snd# active X)
      (active# pair(X1, X2) -> active# X2, active# snd X -> active# X)
      (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# pair(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
      (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
      (active# sel(X1, X2) -> active# X2, active# tail X -> tail# active X)
      (active# sel(X1, X2) -> active# X2, active# tail X -> active# X)
      (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
      (active# sel(X1, X2) -> active# X2, active# s X -> s# active X)
      (active# sel(X1, X2) -> active# X2, active# s X -> active# X)
      (active# sel(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
      (active# sel(X1, X2) -> active# X2, active# natsFrom X -> active# X)
      (active# sel(X1, X2) -> active# X2, active# natsFrom N -> s# N)
      (active# sel(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
      (active# sel(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# sel(X1, X2) -> active# X2, active# head X -> head# active X)
      (active# sel(X1, X2) -> active# X2, active# head X -> active# X)
      (active# sel(X1, X2) -> active# X2, active# fst X -> fst# active X)
      (active# sel(X1, X2) -> active# X2, active# fst X -> active# X)
      (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# sel(X1, X2) -> active# X2, active# snd X -> snd# active X)
      (active# sel(X1, X2) -> active# X2, active# snd X -> active# X)
      (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# sel(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
      (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# U12(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# U12(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# U12(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# U12(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# U12(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# U12(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# U12(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> s# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> head# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# take(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# take(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# take(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# take(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# take(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# take(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# take(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (active# U12(X1, X2) -> U12#(active X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
      (active# U12(X1, X2) -> U12#(active X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
      (active# pair(X1, X2) -> pair#(active X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
      (active# pair(X1, X2) -> pair#(active X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
      (active# pair(X1, X2) -> pair#(active X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
      (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
      (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
      (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
      (active# sel(X1, X2) -> sel#(active X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
      (active# sel(X1, X2) -> sel#(active X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
      (active# sel(X1, X2) -> sel#(active X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
      (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(ok X1, ok X2) -> pair#(X1, X2))
      (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(mark X1, X2) -> pair#(X1, X2))
      (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(X1, mark X2) -> pair#(X1, X2))
      (U12#(mark X1, X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
      (U12#(mark X1, X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
      (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
      (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
      (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
      (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
      (pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(X1, mark X2) -> pair#(X1, X2))
      (cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
      (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok 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#(X1, mark X2) -> afterNth#(X1, X2))
      (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
      (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
      (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
      (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
      (sel#(mark X1, X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(X1, mark X2) -> sel#(X1, X2))
      (take#(X1, mark X2) -> take#(X1, X2), take#(ok X1, ok 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#(X1, mark X2) -> take#(X1, X2))
      (take#(ok X1, ok X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
      (take#(ok X1, ok X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2))
      (take#(ok X1, ok X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
      (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
      (active# take(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# splitAt(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# splitAt(X1, X2) -> active# X1, active# s X -> active# X)
      (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# splitAt(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# splitAt(X1, X2) -> active# X1, active# head X -> active# X)
      (active# splitAt(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# splitAt(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# splitAt(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# splitAt(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# pair(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# pair(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# pair(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# pair(X1, X2) -> active# X1, active# s X -> active# X)
      (active# pair(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# pair(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# pair(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# pair(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# pair(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# pair(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# pair(X1, X2) -> active# X1, active# head X -> active# X)
      (active# pair(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# pair(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# pair(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# pair(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# pair(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# ok X -> snd# X)
      (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# mark X -> snd# X)
      (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# and(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# and(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# and(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# and(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# and(X1, X2) -> active# X1, active# s X -> active# X)
      (active# and(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# and(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# and(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# and(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# and(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# and(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# and(X1, X2) -> active# X1, active# head X -> active# X)
      (active# and(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# and(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# and(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# and(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# and(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# sel(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# sel(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# sel(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# sel(X1, X2) -> active# X1, active# s X -> active# X)
      (active# sel(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# sel(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# sel(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# sel(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# sel(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# sel(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# sel(X1, X2) -> active# X1, active# head X -> active# X)
      (active# sel(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# sel(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# sel(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# sel(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# sel(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# take(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# take(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# take(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# take(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# take(X1, X2) -> active# X1, active# s X -> active# X)
      (active# take(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# take(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# take(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# take(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# take(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# take(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# take(X1, X2) -> active# X1, active# head X -> active# X)
      (active# take(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# take(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# take(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# take(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# take(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# pair(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# pair(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# pair(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# pair(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# pair(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# pair(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# pair(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# sel(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# sel(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# sel(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# sel(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# sel(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# sel(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# sel(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> tail# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> s# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> natsFrom# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> head# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> fst# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> snd# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (active# pair(X1, X2) -> pair#(X1, active X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
      (active# pair(X1, X2) -> pair#(X1, active X2), pair#(mark X1, X2) -> pair#(X1, X2))
      (active# pair(X1, X2) -> pair#(X1, active X2), pair#(X1, mark X2) -> pair#(X1, X2))
      (active# sel(X1, X2) -> sel#(X1, active X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
      (active# sel(X1, X2) -> sel#(X1, active X2), sel#(mark X1, X2) -> sel#(X1, X2))
      (active# sel(X1, X2) -> sel#(X1, active X2), sel#(X1, mark X2) -> sel#(X1, X2))
      (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
      (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(mark X1, X2) -> U12#(X1, X2))
      (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
      (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(mark X1, X2) -> pair#(X1, X2))
      (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(X1, mark X2) -> pair#(X1, X2))
      (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
      (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
      (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
      (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
      (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(mark X1, X2) -> sel#(X1, X2))
      (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(X1, mark X2) -> sel#(X1, X2))
      (active# snd X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (active# snd X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (active# snd X -> active# X, active# take(X1, X2) -> active# X2)
      (active# snd X -> active# X, active# take(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# snd X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (active# snd X -> active# X, active# tail X -> tail# active X)
      (active# snd X -> active# X, active# tail X -> active# X)
      (active# snd X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# snd X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# snd X -> active# X, active# sel(X1, X2) -> active# X2)
      (active# snd X -> active# X, active# sel(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# snd X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (active# snd X -> active# X, active# s X -> s# active X)
      (active# snd X -> active# X, active# s X -> active# X)
      (active# snd X -> active# X, active# natsFrom X -> natsFrom# active X)
      (active# snd X -> active# X, active# natsFrom X -> active# X)
      (active# snd X -> active# X, active# natsFrom N -> s# N)
      (active# snd X -> active# X, active# natsFrom N -> natsFrom# s N)
      (active# snd X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# snd X -> active# X, active# head X -> head# active X)
      (active# snd X -> active# X, active# head X -> active# X)
      (active# snd X -> active# X, active# fst X -> fst# active X)
      (active# snd X -> active# X, active# fst X -> active# X)
      (active# snd X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (active# snd X -> active# X, active# and(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# snd X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# snd X -> active# X, active# snd X -> snd# active X)
      (active# snd X -> active# X, active# snd X -> active# X)
      (active# snd X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# snd X -> active# X, active# cons(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# snd X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# snd X -> active# X, active# pair(X1, X2) -> active# X2)
      (active# snd X -> active# X, active# pair(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# snd X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# snd X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# snd X -> active# X, active# U12(X1, X2) -> active# X1)
      (active# snd X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# head X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (active# head X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (active# head X -> active# X, active# take(X1, X2) -> active# X2)
      (active# head X -> active# X, active# take(X1, X2) -> active# X1)
      (active# head X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# head X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (active# head X -> active# X, active# tail X -> tail# active X)
      (active# head X -> active# X, active# tail X -> active# X)
      (active# head X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# head X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# head X -> active# X, active# sel(X1, X2) -> active# X2)
      (active# head X -> active# X, active# sel(X1, X2) -> active# X1)
      (active# head X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# head X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (active# head X -> active# X, active# s X -> s# active X)
      (active# head X -> active# X, active# s X -> active# X)
      (active# head X -> active# X, active# natsFrom X -> natsFrom# active X)
      (active# head X -> active# X, active# natsFrom X -> active# X)
      (active# head X -> active# X, active# natsFrom N -> s# N)
      (active# head X -> active# X, active# natsFrom N -> natsFrom# s N)
      (active# head X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# head X -> active# X, active# head X -> head# active X)
      (active# head X -> active# X, active# head X -> active# X)
      (active# head X -> active# X, active# fst X -> fst# active X)
      (active# head X -> active# X, active# fst X -> active# X)
      (active# head X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (active# head X -> active# X, active# and(X1, X2) -> active# X1)
      (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# head X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (active# head X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (active# head X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# head X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# head X -> active# X, active# snd X -> snd# active X)
      (active# head X -> active# X, active# snd X -> active# X)
      (active# head X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# head X -> active# X, active# cons(X1, X2) -> active# X1)
      (active# head X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# head X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# head X -> active# X, active# pair(X1, X2) -> active# X2)
      (active# head X -> active# X, active# pair(X1, X2) -> active# X1)
      (active# head X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# head X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# head X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# head X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# head X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (active# head X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# head X -> active# X, active# U12(X1, X2) -> active# X1)
      (active# head X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# s X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (active# s X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (active# s X -> active# X, active# take(X1, X2) -> active# X2)
      (active# s X -> active# X, active# take(X1, X2) -> active# X1)
      (active# s X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# s X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (active# s X -> active# X, active# tail X -> tail# active X)
      (active# s X -> active# X, active# tail X -> active# X)
      (active# s X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# s X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# s X -> active# X, active# sel(X1, X2) -> active# X2)
      (active# s X -> active# X, active# sel(X1, X2) -> active# X1)
      (active# s X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# s X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (active# s X -> active# X, active# s X -> s# active X)
      (active# s X -> active# X, active# s X -> active# X)
      (active# s X -> active# X, active# natsFrom X -> natsFrom# active X)
      (active# s X -> active# X, active# natsFrom X -> active# X)
      (active# s X -> active# X, active# natsFrom N -> s# N)
      (active# s X -> active# X, active# natsFrom N -> natsFrom# s N)
      (active# s X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# s X -> active# X, active# head X -> head# active X)
      (active# s X -> active# X, active# head X -> active# X)
      (active# s X -> active# X, active# fst X -> fst# active X)
      (active# s X -> active# X, active# fst X -> active# X)
      (active# s X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (active# s X -> active# X, active# and(X1, X2) -> active# X1)
      (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# s X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (active# s X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (active# s X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# s X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# s X -> active# X, active# snd X -> snd# active X)
      (active# s X -> active# X, active# snd X -> active# X)
      (active# s X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# s X -> active# X, active# cons(X1, X2) -> active# X1)
      (active# s X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# s X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# s X -> active# X, active# pair(X1, X2) -> active# X2)
      (active# s X -> active# X, active# pair(X1, X2) -> active# X1)
      (active# s X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# s X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# s X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# s X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# s X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (active# s X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# s X -> active# X, active# U12(X1, X2) -> active# X1)
      (active# s X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (snd# mark X -> snd# X, snd# ok X -> snd# X)
      (snd# mark X -> snd# X, snd# mark X -> snd# X)
      (fst# mark X -> fst# X, fst# ok X -> fst# X)
      (fst# mark X -> fst# X, fst# mark X -> fst# X)
      (head# mark X -> head# X, head# ok X -> head# X)
      (head# mark X -> head# X, head# mark X -> head# X)
      (natsFrom# mark X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
      (natsFrom# mark X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
      (s# mark X -> s# X, s# ok X -> s# X)
      (s# mark X -> s# X, s# mark X -> s# X)
      (tail# mark X -> tail# X, tail# ok X -> tail# X)
      (tail# mark X -> tail# X, tail# mark X -> tail# X)
      (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# tail X -> proper# X)
      (proper# snd X -> proper# X, proper# tail X -> tail# proper X)
      (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# s X -> proper# X)
      (proper# snd X -> proper# X, proper# s X -> s# proper X)
      (proper# snd X -> proper# X, proper# natsFrom X -> proper# X)
      (proper# snd X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (proper# snd X -> proper# X, proper# head X -> proper# X)
      (proper# snd X -> proper# X, proper# head X -> head# proper X)
      (proper# snd X -> proper# X, proper# fst X -> proper# X)
      (proper# snd X -> proper# X, proper# fst X -> fst# proper X)
      (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# snd X -> proper# X)
      (proper# snd X -> proper# X, proper# snd X -> snd# proper X)
      (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (proper# snd X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# tail X -> proper# X)
      (proper# head X -> proper# X, proper# tail X -> tail# proper X)
      (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# s X -> proper# X)
      (proper# head X -> proper# X, proper# s X -> s# proper X)
      (proper# head X -> proper# X, proper# natsFrom X -> proper# X)
      (proper# head X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (proper# head X -> proper# X, proper# head X -> proper# X)
      (proper# head X -> proper# X, proper# head X -> head# proper X)
      (proper# head X -> proper# X, proper# fst X -> proper# X)
      (proper# head X -> proper# X, proper# fst X -> fst# proper X)
      (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# snd X -> proper# X)
      (proper# head X -> proper# X, proper# snd X -> snd# proper X)
      (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (proper# head X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# tail X -> proper# X)
      (proper# s X -> proper# X, proper# tail X -> tail# proper X)
      (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# s X -> proper# X)
      (proper# s X -> proper# X, proper# s X -> s# proper X)
      (proper# s X -> proper# X, proper# natsFrom X -> proper# X)
      (proper# s X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (proper# s X -> proper# X, proper# head X -> proper# X)
      (proper# s X -> proper# X, proper# head X -> head# proper X)
      (proper# s X -> proper# X, proper# fst X -> proper# X)
      (proper# s X -> proper# X, proper# fst X -> fst# proper X)
      (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# snd X -> proper# X)
      (proper# s X -> proper# X, proper# snd X -> snd# proper X)
      (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# tail X -> proper# X)
      (top# mark X -> proper# X, proper# tail X -> tail# proper X)
      (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# s X -> proper# X)
      (top# mark X -> proper# X, proper# s X -> s# proper X)
      (top# mark X -> proper# X, proper# natsFrom X -> proper# X)
      (top# mark X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (top# mark X -> proper# X, proper# head X -> proper# X)
      (top# mark X -> proper# X, proper# head X -> head# proper X)
      (top# mark X -> proper# X, proper# fst X -> proper# X)
      (top# mark X -> proper# X, proper# fst X -> fst# proper X)
      (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# snd X -> proper# X)
      (top# mark X -> proper# X, proper# snd X -> snd# proper X)
      (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (active# snd X -> snd# active X, snd# ok X -> snd# X)
      (active# snd X -> snd# active X, snd# mark X -> snd# X)
      (active# head X -> head# active X, head# ok X -> head# X)
      (active# head X -> head# active X, head# mark X -> head# X)
      (active# s X -> s# active X, s# ok X -> s# X)
      (active# s X -> s# active X, s# mark X -> s# X)
      (proper# snd X -> snd# proper X, snd# ok X -> snd# X)
      (proper# snd X -> snd# proper X, snd# mark X -> snd# X)
      (proper# head X -> head# proper X, head# ok X -> head# X)
      (proper# head X -> head# proper X, head# mark X -> head# X)
      (proper# s X -> s# proper X, s# ok X -> s# X)
      (proper# s X -> s# proper X, s# mark X -> s# X)
      (top# mark X -> top# proper X, top# ok X -> top# active X)
      (top# mark X -> top# proper X, top# ok X -> active# X)
      (top# mark X -> top# proper X, top# mark X -> top# proper X)
      (top# mark X -> top# proper X, top# mark X -> proper# X)
      (active# natsFrom N -> natsFrom# s N, natsFrom# ok X -> natsFrom# X)
      (active# natsFrom N -> natsFrom# s N, natsFrom# mark X -> natsFrom# X)
      (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(mark X1, X2) -> cons#(X1, X2))
      (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(ok X1, ok X2) -> U12#(X1, X2))
      (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(mark X1, X2) -> U12#(X1, X2))
      (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
      (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
      (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, mark X2) -> pair#(X1, X2))
      (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
      (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
      (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
      (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> snd# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> fst# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> head# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> natsFrom# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> s# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> tail# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
      (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
      (top# ok X -> top# active X, top# mark X -> proper# X)
      (top# ok X -> top# active X, top# mark X -> top# proper X)
      (top# ok X -> top# active X, top# ok X -> active# X)
      (top# ok X -> top# active X, top# ok X -> top# active X)
      (proper# tail X -> tail# proper X, tail# mark X -> tail# X)
      (proper# tail X -> tail# proper X, tail# ok X -> tail# X)
      (proper# natsFrom X -> natsFrom# proper X, natsFrom# mark X -> natsFrom# X)
      (proper# natsFrom X -> natsFrom# proper X, natsFrom# ok X -> natsFrom# X)
      (proper# fst X -> fst# proper X, fst# mark X -> fst# X)
      (proper# fst X -> fst# proper X, fst# ok X -> fst# X)
      (active# tail X -> tail# active X, tail# mark X -> tail# X)
      (active# tail X -> tail# active X, tail# ok X -> tail# X)
      (active# natsFrom X -> natsFrom# active X, natsFrom# mark X -> natsFrom# X)
      (active# natsFrom X -> natsFrom# active X, natsFrom# ok X -> natsFrom# X)
      (active# fst X -> fst# active X, fst# mark X -> fst# X)
      (active# fst X -> fst# active X, fst# ok X -> fst# X)
      (top# ok X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (top# ok X -> active# X, active# U12(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (top# ok X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (top# ok X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (top# ok X -> active# X, active# pair(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# pair(X1, X2) -> active# X2)
      (top# ok X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (top# ok X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (top# ok X -> active# X, active# cons(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (top# ok X -> active# X, active# snd X -> active# X)
      (top# ok X -> active# X, active# snd X -> snd# active X)
      (top# ok X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (top# ok X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (top# ok X -> active# X, active# fst X -> active# X)
      (top# ok X -> active# X, active# fst X -> fst# active X)
      (top# ok X -> active# X, active# head X -> active# X)
      (top# ok X -> active# X, active# head X -> head# active X)
      (top# ok X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (top# ok X -> active# X, active# natsFrom N -> natsFrom# s N)
      (top# ok X -> active# X, active# natsFrom N -> s# N)
      (top# ok X -> active# X, active# natsFrom X -> active# X)
      (top# ok X -> active# X, active# natsFrom X -> natsFrom# active X)
      (top# ok X -> active# X, active# s X -> active# X)
      (top# ok X -> active# X, active# s X -> s# active X)
      (top# ok X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (top# ok X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (top# ok X -> active# X, active# sel(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# sel(X1, X2) -> active# X2)
      (top# ok X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (top# ok X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (top# ok X -> active# X, active# tail X -> active# X)
      (top# ok X -> active# X, active# tail X -> tail# active X)
      (top# ok X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (top# ok X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (top# ok X -> active# X, active# take(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# take(X1, X2) -> active# X2)
      (top# ok X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (top# ok X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (proper# tail X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# tail X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# snd X -> snd# proper X)
      (proper# tail X -> proper# X, proper# snd X -> proper# X)
      (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# fst X -> fst# proper X)
      (proper# tail X -> proper# X, proper# fst X -> proper# X)
      (proper# tail X -> proper# X, proper# head X -> head# proper X)
      (proper# tail X -> proper# X, proper# head X -> proper# X)
      (proper# tail X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (proper# tail X -> proper# X, proper# natsFrom X -> proper# X)
      (proper# tail X -> proper# X, proper# s X -> s# proper X)
      (proper# tail X -> proper# X, proper# s X -> proper# X)
      (proper# tail X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (proper# tail X -> proper# X, proper# tail X -> tail# proper X)
      (proper# tail X -> proper# X, proper# tail X -> proper# X)
      (proper# tail X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# snd X -> snd# proper X)
      (proper# natsFrom X -> proper# X, proper# snd X -> proper# X)
      (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# fst X -> fst# proper X)
      (proper# natsFrom X -> proper# X, proper# fst X -> proper# X)
      (proper# natsFrom X -> proper# X, proper# head X -> head# proper X)
      (proper# natsFrom X -> proper# X, proper# head X -> proper# X)
      (proper# natsFrom X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (proper# natsFrom X -> proper# X, proper# natsFrom X -> proper# X)
      (proper# natsFrom X -> proper# X, proper# s X -> s# proper X)
      (proper# natsFrom X -> proper# X, proper# s X -> proper# X)
      (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (proper# natsFrom X -> proper# X, proper# tail X -> tail# proper X)
      (proper# natsFrom X -> proper# X, proper# tail X -> proper# X)
      (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# fst X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# snd X -> snd# proper X)
      (proper# fst X -> proper# X, proper# snd X -> proper# X)
      (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# fst X -> fst# proper X)
      (proper# fst X -> proper# X, proper# fst X -> proper# X)
      (proper# fst X -> proper# X, proper# head X -> head# proper X)
      (proper# fst X -> proper# X, proper# head X -> proper# X)
      (proper# fst X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
      (proper# fst X -> proper# X, proper# natsFrom X -> proper# X)
      (proper# fst X -> proper# X, proper# s X -> s# proper X)
      (proper# fst X -> proper# X, proper# s X -> proper# X)
      (proper# fst X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X2)
      (proper# fst X -> proper# X, proper# tail X -> tail# proper X)
      (proper# fst X -> proper# X, proper# tail X -> proper# X)
      (proper# fst X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X1)
      (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X2)
      (tail# ok X -> tail# X, tail# mark X -> tail# X)
      (tail# ok X -> tail# X, tail# ok X -> tail# X)
      (s# ok X -> s# X, s# mark X -> s# X)
      (s# ok X -> s# X, s# ok X -> s# X)
      (natsFrom# ok X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
      (natsFrom# ok X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
      (head# ok X -> head# X, head# mark X -> head# X)
      (head# ok X -> head# X, head# ok X -> head# X)
      (fst# ok X -> fst# X, fst# mark X -> fst# X)
      (fst# ok X -> fst# X, fst# ok X -> fst# X)
      (snd# ok X -> snd# X, snd# mark X -> snd# X)
      (snd# ok X -> snd# X, snd# ok X -> snd# X)
      (active# tail X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# tail X -> active# X, active# U12(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (active# tail X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# tail X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# tail X -> active# X, active# pair(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# pair(X1, X2) -> active# X2)
      (active# tail X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# tail X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# tail X -> active# X, active# cons(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# tail X -> active# X, active# snd X -> active# X)
      (active# tail X -> active# X, active# snd X -> snd# active X)
      (active# tail X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# tail X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# tail X -> active# X, active# and(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (active# tail X -> active# X, active# fst X -> active# X)
      (active# tail X -> active# X, active# fst X -> fst# active X)
      (active# tail X -> active# X, active# head X -> active# X)
      (active# tail X -> active# X, active# head X -> head# active X)
      (active# tail X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# tail X -> active# X, active# natsFrom N -> natsFrom# s N)
      (active# tail X -> active# X, active# natsFrom N -> s# N)
      (active# tail X -> active# X, active# natsFrom X -> active# X)
      (active# tail X -> active# X, active# natsFrom X -> natsFrom# active X)
      (active# tail X -> active# X, active# s X -> active# X)
      (active# tail X -> active# X, active# s X -> s# active X)
      (active# tail X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (active# tail X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# tail X -> active# X, active# sel(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# sel(X1, X2) -> active# X2)
      (active# tail X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# tail X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# tail X -> active# X, active# tail X -> active# X)
      (active# tail X -> active# X, active# tail X -> tail# active X)
      (active# tail X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (active# tail X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# tail X -> active# X, active# take(X1, X2) -> active# X1)
      (active# tail X -> active# X, active# take(X1, X2) -> active# X2)
      (active# tail X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (active# tail X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (active# natsFrom X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# natsFrom X -> active# X, active# U12(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (active# natsFrom X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# natsFrom X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X2)
      (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# natsFrom X -> active# X, active# cons(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# natsFrom X -> active# X, active# snd X -> active# X)
      (active# natsFrom X -> active# X, active# snd X -> snd# active X)
      (active# natsFrom X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# natsFrom X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# natsFrom X -> active# X, active# and(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (active# natsFrom X -> active# X, active# fst X -> active# X)
      (active# natsFrom X -> active# X, active# fst X -> fst# active X)
      (active# natsFrom X -> active# X, active# head X -> active# X)
      (active# natsFrom X -> active# X, active# head X -> head# active X)
      (active# natsFrom X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# natsFrom X -> active# X, active# natsFrom N -> natsFrom# s N)
      (active# natsFrom X -> active# X, active# natsFrom N -> s# N)
      (active# natsFrom X -> active# X, active# natsFrom X -> active# X)
      (active# natsFrom X -> active# X, active# natsFrom X -> natsFrom# active X)
      (active# natsFrom X -> active# X, active# s X -> active# X)
      (active# natsFrom X -> active# X, active# s X -> s# active X)
      (active# natsFrom X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (active# natsFrom X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X2)
      (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# natsFrom X -> active# X, active# tail X -> active# X)
      (active# natsFrom X -> active# X, active# tail X -> tail# active X)
      (active# natsFrom X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (active# natsFrom X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X1)
      (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X2)
      (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (active# fst X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# fst X -> active# X, active# U12(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X2)
      (active# fst X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# fst X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# fst X -> active# X, active# pair(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# pair(X1, X2) -> active# X2)
      (active# fst X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# fst X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# fst X -> active# X, active# cons(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# fst X -> active# X, active# snd X -> active# X)
      (active# fst X -> active# X, active# snd X -> snd# active X)
      (active# fst X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# fst X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X2)
      (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# fst X -> active# X, active# and(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (active# fst X -> active# X, active# fst X -> active# X)
      (active# fst X -> active# X, active# fst X -> fst# active X)
      (active# fst X -> active# X, active# head X -> active# X)
      (active# fst X -> active# X, active# head X -> head# active X)
      (active# fst X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# fst X -> active# X, active# natsFrom N -> natsFrom# s N)
      (active# fst X -> active# X, active# natsFrom N -> s# N)
      (active# fst X -> active# X, active# natsFrom X -> active# X)
      (active# fst X -> active# X, active# natsFrom X -> natsFrom# active X)
      (active# fst X -> active# X, active# s X -> active# X)
      (active# fst X -> active# X, active# s X -> s# active X)
      (active# fst X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
      (active# fst X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# fst X -> active# X, active# sel(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# sel(X1, X2) -> active# X2)
      (active# fst X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# fst X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# fst X -> active# X, active# tail X -> active# X)
      (active# fst X -> active# X, active# tail X -> tail# active X)
      (active# fst X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
      (active# fst X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# fst X -> active# X, active# take(X1, X2) -> active# X1)
      (active# fst X -> active# X, active# take(X1, X2) -> active# X2)
      (active# fst X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
      (active# fst X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
      (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(X1, mark X2) -> take#(X1, X2))
      (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(mark X1, X2) -> take#(X1, X2))
      (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(ok X1, ok X2) -> take#(X1, X2))
      (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
      (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(mark X1, X2) -> cons#(X1, X2))
      (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
      (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
      (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
      (active# take(X1, X2) -> take#(X1, active X2), take#(X1, mark X2) -> take#(X1, X2))
      (active# take(X1, X2) -> take#(X1, active X2), take#(mark X1, X2) -> take#(X1, X2))
      (active# take(X1, X2) -> take#(X1, active X2), take#(ok X1, ok X2) -> take#(X1, X2))
      (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
      (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
      (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
      (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
      (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
      (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
      (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# take(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# take(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# take(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# take(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# take(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# take(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# take(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# take(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> head# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> s# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> proper# X)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
      (proper# U12(X1, X2) -> proper# X1, proper# snd X -> proper# X)
      (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
      (proper# U12(X1, X2) -> proper# X1, proper# fst X -> proper# X)
      (proper# U12(X1, X2) -> proper# X1, proper# head X -> head# proper X)
      (proper# U12(X1, X2) -> proper# X1, proper# head X -> proper# X)
      (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
      (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
      (proper# U12(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# U12(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
      (proper# U12(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
      (proper# U12(X1, X2) -> proper# X1, proper# tail X -> proper# X)
      (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
      (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
      (active# take(N, XS) -> fst# splitAt(N, XS), fst# mark X -> fst# X)
      (active# take(N, XS) -> fst# splitAt(N, XS), fst# ok X -> fst# X)
      (active# sel(N, XS) -> head# afterNth(N, XS), head# mark X -> head# X)
      (active# sel(N, XS) -> head# afterNth(N, XS), head# ok X -> head# X)
      (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# afterNth(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# afterNth(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# afterNth(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# afterNth(X1, X2) -> active# X1, active# head X -> active# X)
      (active# afterNth(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# afterNth(X1, X2) -> active# X1, active# s X -> active# X)
      (active# afterNth(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# afterNth(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# cons(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# cons(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# cons(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# cons(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# cons(X1, X2) -> active# X1, active# head X -> active# X)
      (active# cons(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# cons(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# cons(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# cons(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# cons(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# cons(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# cons(X1, X2) -> active# X1, active# s X -> active# X)
      (active# cons(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# cons(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# cons(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> active# X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> snd# active X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> active# X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> fst# active X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> active# X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> head# active X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> s# N)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> active# X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> active# X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> s# active X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> active# X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> tail# active X)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
      (active# U12(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# U12(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
      (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# snd X -> active# X)
      (active# U12(X1, X2) -> active# X1, active# snd X -> snd# active X)
      (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
      (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# fst X -> active# X)
      (active# U12(X1, X2) -> active# X1, active# fst X -> fst# active X)
      (active# U12(X1, X2) -> active# X1, active# head X -> active# X)
      (active# U12(X1, X2) -> active# X1, active# head X -> head# active X)
      (active# U12(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# U12(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
      (active# U12(X1, X2) -> active# X1, active# natsFrom N -> s# N)
      (active# U12(X1, X2) -> active# X1, active# natsFrom X -> active# X)
      (active# U12(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
      (active# U12(X1, X2) -> active# X1, active# s X -> active# X)
      (active# U12(X1, X2) -> active# X1, active# s X -> s# active X)
      (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
      (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
      (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# U12(X1, X2) -> active# X1, active# tail X -> active# X)
      (active# U12(X1, X2) -> active# X1, active# tail X -> tail# active X)
      (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
      (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
      (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
      (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
      (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
      (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
      (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
      (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
      (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
      (take#(mark X1, X2) -> take#(X1, X2), take#(X1, mark 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#(ok X1, ok X2) -> take#(X1, X2))
      (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
      (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
      (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(mark X1, X2) -> sel#(X1, X2))
      (sel#(X1, mark X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
      (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
      (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
      (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
      (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
      (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
      (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(mark X1, X2) -> pair#(X1, X2))
      (pair#(X1, mark X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
      (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark 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#(ok X1, ok X2) -> splitAt#(X1, X2))
      (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
      (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(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#(ok X1, ok X2) -> cons#(X1, X2))
      (active# take(X1, X2) -> take#(active X1, X2), take#(X1, mark X2) -> take#(X1, X2))
      (active# take(X1, X2) -> take#(active X1, X2), take#(mark X1, X2) -> take#(X1, X2))
      (active# take(X1, X2) -> take#(active X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
      (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
      (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (active# cons(X1, X2) -> cons#(active X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
      (active# cons(X1, X2) -> cons#(active X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
      (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
      (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
      (active# natsFrom N -> s# N, s# mark X -> s# X)
      (active# natsFrom N -> s# N, s# ok X -> s# X)
      (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# sel(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# sel(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# sel(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# sel(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# sel(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# sel(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# sel(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# sel(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# pair(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# pair(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# pair(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# pair(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# pair(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# pair(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# pair(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
      (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
      (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
      (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> head# proper X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
      (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> proper# X)
      (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
      (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
      (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
      (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# take(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# snd X -> active# X)
      (active# take(X1, X2) -> active# X2, active# snd X -> snd# active X)
      (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# fst X -> active# X)
      (active# take(X1, X2) -> active# X2, active# fst X -> fst# active X)
      (active# take(X1, X2) -> active# X2, active# head X -> active# X)
      (active# take(X1, X2) -> active# X2, active# head X -> head# active X)
      (active# take(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# take(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
      (active# take(X1, X2) -> active# X2, active# natsFrom N -> s# N)
      (active# take(X1, X2) -> active# X2, active# natsFrom X -> active# X)
      (active# take(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
      (active# take(X1, X2) -> active# X2, active# s X -> active# X)
      (active# take(X1, X2) -> active# X2, active# s X -> s# active X)
      (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
      (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# take(X1, X2) -> active# X2, active# tail X -> active# X)
      (active# take(X1, X2) -> active# X2, active# tail X -> tail# active X)
      (active# take(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
      (active# take(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
      (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
      (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
      (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# afterNth(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# snd X -> active# X)
      (active# afterNth(X1, X2) -> active# X2, active# snd X -> snd# active X)
      (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# fst X -> active# X)
      (active# afterNth(X1, X2) -> active# X2, active# fst X -> fst# active X)
      (active# afterNth(X1, X2) -> active# X2, active# head X -> active# X)
      (active# afterNth(X1, X2) -> active# X2, active# head X -> head# active X)
      (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
      (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> s# N)
      (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> active# X)
      (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
      (active# afterNth(X1, X2) -> active# X2, active# s X -> active# X)
      (active# afterNth(X1, X2) -> active# X2, active# s X -> s# active X)
      (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# afterNth(X1, X2) -> active# X2, active# tail X -> active# X)
      (active# afterNth(X1, X2) -> active# X2, active# tail X -> tail# active X)
      (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
      (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
      (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
      (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
      (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
      (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
      (active# splitAt(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
      (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
      (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
      (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# snd X -> active# X)
      (active# splitAt(X1, X2) -> active# X2, active# snd X -> snd# active X)
      (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# fst X -> active# X)
      (active# splitAt(X1, X2) -> active# X2, active# fst X -> fst# active X)
      (active# splitAt(X1, X2) -> active# X2, active# head X -> active# X)
      (active# splitAt(X1, X2) -> active# X2, active# head X -> head# active X)
      (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
      (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
      (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> s# N)
      (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> active# X)
      (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
      (active# splitAt(X1, X2) -> active# X2, active# s X -> active# X)
      (active# splitAt(X1, X2) -> active# X2, active# s X -> s# active X)
      (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
      (active# splitAt(X1, X2) -> active# X2, active# tail X -> active# X)
      (active# splitAt(X1, X2) -> active# X2, active# tail X -> tail# active X)
      (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
      (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
      (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
      (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
      (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
     }
     EDG:
      {
       (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
       (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
       (active# pair(X1, X2) -> active# X2, active# tail X -> tail# active X)
       (active# pair(X1, X2) -> active# X2, active# tail X -> active# X)
       (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
       (active# pair(X1, X2) -> active# X2, active# s X -> s# active X)
       (active# pair(X1, X2) -> active# X2, active# s X -> active# X)
       (active# pair(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
       (active# pair(X1, X2) -> active# X2, active# natsFrom X -> active# X)
       (active# pair(X1, X2) -> active# X2, active# natsFrom N -> s# N)
       (active# pair(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
       (active# pair(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# pair(X1, X2) -> active# X2, active# head X -> head# active X)
       (active# pair(X1, X2) -> active# X2, active# head X -> active# X)
       (active# pair(X1, X2) -> active# X2, active# fst X -> fst# active X)
       (active# pair(X1, X2) -> active# X2, active# fst X -> active# X)
       (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# pair(X1, X2) -> active# X2, active# snd X -> snd# active X)
       (active# pair(X1, X2) -> active# X2, active# snd X -> active# X)
       (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# pair(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
       (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
       (active# sel(X1, X2) -> active# X2, active# tail X -> tail# active X)
       (active# sel(X1, X2) -> active# X2, active# tail X -> active# X)
       (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
       (active# sel(X1, X2) -> active# X2, active# s X -> s# active X)
       (active# sel(X1, X2) -> active# X2, active# s X -> active# X)
       (active# sel(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
       (active# sel(X1, X2) -> active# X2, active# natsFrom X -> active# X)
       (active# sel(X1, X2) -> active# X2, active# natsFrom N -> s# N)
       (active# sel(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
       (active# sel(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# sel(X1, X2) -> active# X2, active# head X -> head# active X)
       (active# sel(X1, X2) -> active# X2, active# head X -> active# X)
       (active# sel(X1, X2) -> active# X2, active# fst X -> fst# active X)
       (active# sel(X1, X2) -> active# X2, active# fst X -> active# X)
       (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# sel(X1, X2) -> active# X2, active# snd X -> snd# active X)
       (active# sel(X1, X2) -> active# X2, active# snd X -> active# X)
       (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# sel(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
       (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# U12(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# U12(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# U12(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# U12(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# U12(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# U12(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# U12(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> s# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> head# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# take(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# take(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# take(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# take(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# take(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# take(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# take(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (active# U12(X1, X2) -> U12#(active X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
       (active# U12(X1, X2) -> U12#(active X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
       (active# pair(X1, X2) -> pair#(active X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
       (active# pair(X1, X2) -> pair#(active X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
       (active# pair(X1, X2) -> pair#(active X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
       (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
       (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
       (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
       (active# sel(X1, X2) -> sel#(active X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
       (active# sel(X1, X2) -> sel#(active X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
       (active# sel(X1, X2) -> sel#(active X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
       (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(ok X1, ok X2) -> pair#(X1, X2))
       (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(mark X1, X2) -> pair#(X1, X2))
       (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(X1, mark X2) -> pair#(X1, X2))
       (U12#(mark X1, X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
       (U12#(mark X1, X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
       (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
       (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
       (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
       (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
       (pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(X1, mark X2) -> pair#(X1, X2))
       (cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
       (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok 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#(X1, mark X2) -> afterNth#(X1, X2))
       (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
       (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
       (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
       (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
       (sel#(mark X1, X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(X1, mark X2) -> sel#(X1, X2))
       (take#(X1, mark X2) -> take#(X1, X2), take#(ok X1, ok 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#(X1, mark X2) -> take#(X1, X2))
       (take#(ok X1, ok X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
       (take#(ok X1, ok X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2))
       (take#(ok X1, ok X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
       (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
       (active# take(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# splitAt(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# splitAt(X1, X2) -> active# X1, active# s X -> active# X)
       (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# splitAt(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# splitAt(X1, X2) -> active# X1, active# head X -> active# X)
       (active# splitAt(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# splitAt(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# splitAt(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# splitAt(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# pair(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# pair(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# pair(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# pair(X1, X2) -> active# X1, active# s X -> active# X)
       (active# pair(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# pair(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# pair(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# pair(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# pair(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# pair(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# pair(X1, X2) -> active# X1, active# head X -> active# X)
       (active# pair(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# pair(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# pair(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# pair(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# pair(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# ok X -> snd# X)
       (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# mark X -> snd# X)
       (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# and(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# and(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# and(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# and(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# and(X1, X2) -> active# X1, active# s X -> active# X)
       (active# and(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# and(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# and(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# and(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# and(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# and(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# and(X1, X2) -> active# X1, active# head X -> active# X)
       (active# and(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# and(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# and(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# and(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# and(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# sel(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# sel(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# sel(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# sel(X1, X2) -> active# X1, active# s X -> active# X)
       (active# sel(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# sel(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# sel(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# sel(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# sel(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# sel(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# sel(X1, X2) -> active# X1, active# head X -> active# X)
       (active# sel(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# sel(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# sel(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# sel(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# sel(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# take(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# take(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# take(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# take(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# take(X1, X2) -> active# X1, active# s X -> active# X)
       (active# take(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# take(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# take(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# take(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# take(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# take(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# take(X1, X2) -> active# X1, active# head X -> active# X)
       (active# take(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# take(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# take(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# take(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# take(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# pair(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# pair(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# pair(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# pair(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# pair(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# pair(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# pair(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# sel(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# sel(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# sel(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# sel(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# sel(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# sel(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# sel(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> tail# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> s# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> natsFrom# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> head# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> fst# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> snd# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (active# pair(X1, X2) -> pair#(X1, active X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
       (active# pair(X1, X2) -> pair#(X1, active X2), pair#(mark X1, X2) -> pair#(X1, X2))
       (active# pair(X1, X2) -> pair#(X1, active X2), pair#(X1, mark X2) -> pair#(X1, X2))
       (active# sel(X1, X2) -> sel#(X1, active X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
       (active# sel(X1, X2) -> sel#(X1, active X2), sel#(mark X1, X2) -> sel#(X1, X2))
       (active# sel(X1, X2) -> sel#(X1, active X2), sel#(X1, mark X2) -> sel#(X1, X2))
       (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
       (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(mark X1, X2) -> U12#(X1, X2))
       (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
       (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(mark X1, X2) -> pair#(X1, X2))
       (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(X1, mark X2) -> pair#(X1, X2))
       (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
       (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
       (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
       (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
       (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(mark X1, X2) -> sel#(X1, X2))
       (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(X1, mark X2) -> sel#(X1, X2))
       (active# snd X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (active# snd X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (active# snd X -> active# X, active# take(X1, X2) -> active# X2)
       (active# snd X -> active# X, active# take(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# snd X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (active# snd X -> active# X, active# tail X -> tail# active X)
       (active# snd X -> active# X, active# tail X -> active# X)
       (active# snd X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# snd X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# snd X -> active# X, active# sel(X1, X2) -> active# X2)
       (active# snd X -> active# X, active# sel(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# snd X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (active# snd X -> active# X, active# s X -> s# active X)
       (active# snd X -> active# X, active# s X -> active# X)
       (active# snd X -> active# X, active# natsFrom X -> natsFrom# active X)
       (active# snd X -> active# X, active# natsFrom X -> active# X)
       (active# snd X -> active# X, active# natsFrom N -> s# N)
       (active# snd X -> active# X, active# natsFrom N -> natsFrom# s N)
       (active# snd X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# snd X -> active# X, active# head X -> head# active X)
       (active# snd X -> active# X, active# head X -> active# X)
       (active# snd X -> active# X, active# fst X -> fst# active X)
       (active# snd X -> active# X, active# fst X -> active# X)
       (active# snd X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (active# snd X -> active# X, active# and(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# snd X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# snd X -> active# X, active# snd X -> snd# active X)
       (active# snd X -> active# X, active# snd X -> active# X)
       (active# snd X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# snd X -> active# X, active# cons(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# snd X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# snd X -> active# X, active# pair(X1, X2) -> active# X2)
       (active# snd X -> active# X, active# pair(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# snd X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# snd X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# snd X -> active# X, active# U12(X1, X2) -> active# X1)
       (active# snd X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# head X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (active# head X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (active# head X -> active# X, active# take(X1, X2) -> active# X2)
       (active# head X -> active# X, active# take(X1, X2) -> active# X1)
       (active# head X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# head X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (active# head X -> active# X, active# tail X -> tail# active X)
       (active# head X -> active# X, active# tail X -> active# X)
       (active# head X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# head X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# head X -> active# X, active# sel(X1, X2) -> active# X2)
       (active# head X -> active# X, active# sel(X1, X2) -> active# X1)
       (active# head X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# head X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (active# head X -> active# X, active# s X -> s# active X)
       (active# head X -> active# X, active# s X -> active# X)
       (active# head X -> active# X, active# natsFrom X -> natsFrom# active X)
       (active# head X -> active# X, active# natsFrom X -> active# X)
       (active# head X -> active# X, active# natsFrom N -> s# N)
       (active# head X -> active# X, active# natsFrom N -> natsFrom# s N)
       (active# head X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# head X -> active# X, active# head X -> head# active X)
       (active# head X -> active# X, active# head X -> active# X)
       (active# head X -> active# X, active# fst X -> fst# active X)
       (active# head X -> active# X, active# fst X -> active# X)
       (active# head X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (active# head X -> active# X, active# and(X1, X2) -> active# X1)
       (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# head X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (active# head X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (active# head X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# head X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# head X -> active# X, active# snd X -> snd# active X)
       (active# head X -> active# X, active# snd X -> active# X)
       (active# head X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# head X -> active# X, active# cons(X1, X2) -> active# X1)
       (active# head X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# head X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# head X -> active# X, active# pair(X1, X2) -> active# X2)
       (active# head X -> active# X, active# pair(X1, X2) -> active# X1)
       (active# head X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# head X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# head X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# head X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# head X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (active# head X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# head X -> active# X, active# U12(X1, X2) -> active# X1)
       (active# head X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# s X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (active# s X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (active# s X -> active# X, active# take(X1, X2) -> active# X2)
       (active# s X -> active# X, active# take(X1, X2) -> active# X1)
       (active# s X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# s X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (active# s X -> active# X, active# tail X -> tail# active X)
       (active# s X -> active# X, active# tail X -> active# X)
       (active# s X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# s X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# s X -> active# X, active# sel(X1, X2) -> active# X2)
       (active# s X -> active# X, active# sel(X1, X2) -> active# X1)
       (active# s X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# s X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (active# s X -> active# X, active# s X -> s# active X)
       (active# s X -> active# X, active# s X -> active# X)
       (active# s X -> active# X, active# natsFrom X -> natsFrom# active X)
       (active# s X -> active# X, active# natsFrom X -> active# X)
       (active# s X -> active# X, active# natsFrom N -> s# N)
       (active# s X -> active# X, active# natsFrom N -> natsFrom# s N)
       (active# s X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# s X -> active# X, active# head X -> head# active X)
       (active# s X -> active# X, active# head X -> active# X)
       (active# s X -> active# X, active# fst X -> fst# active X)
       (active# s X -> active# X, active# fst X -> active# X)
       (active# s X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (active# s X -> active# X, active# and(X1, X2) -> active# X1)
       (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# s X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (active# s X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (active# s X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# s X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# s X -> active# X, active# snd X -> snd# active X)
       (active# s X -> active# X, active# snd X -> active# X)
       (active# s X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# s X -> active# X, active# cons(X1, X2) -> active# X1)
       (active# s X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# s X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# s X -> active# X, active# pair(X1, X2) -> active# X2)
       (active# s X -> active# X, active# pair(X1, X2) -> active# X1)
       (active# s X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# s X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# s X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# s X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# s X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (active# s X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# s X -> active# X, active# U12(X1, X2) -> active# X1)
       (active# s X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (snd# mark X -> snd# X, snd# ok X -> snd# X)
       (snd# mark X -> snd# X, snd# mark X -> snd# X)
       (fst# mark X -> fst# X, fst# ok X -> fst# X)
       (fst# mark X -> fst# X, fst# mark X -> fst# X)
       (head# mark X -> head# X, head# ok X -> head# X)
       (head# mark X -> head# X, head# mark X -> head# X)
       (natsFrom# mark X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
       (natsFrom# mark X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
       (s# mark X -> s# X, s# ok X -> s# X)
       (s# mark X -> s# X, s# mark X -> s# X)
       (tail# mark X -> tail# X, tail# ok X -> tail# X)
       (tail# mark X -> tail# X, tail# mark X -> tail# X)
       (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# tail X -> proper# X)
       (proper# snd X -> proper# X, proper# tail X -> tail# proper X)
       (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# s X -> proper# X)
       (proper# snd X -> proper# X, proper# s X -> s# proper X)
       (proper# snd X -> proper# X, proper# natsFrom X -> proper# X)
       (proper# snd X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (proper# snd X -> proper# X, proper# head X -> proper# X)
       (proper# snd X -> proper# X, proper# head X -> head# proper X)
       (proper# snd X -> proper# X, proper# fst X -> proper# X)
       (proper# snd X -> proper# X, proper# fst X -> fst# proper X)
       (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# snd X -> proper# X)
       (proper# snd X -> proper# X, proper# snd X -> snd# proper X)
       (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (proper# snd X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# tail X -> proper# X)
       (proper# head X -> proper# X, proper# tail X -> tail# proper X)
       (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# s X -> proper# X)
       (proper# head X -> proper# X, proper# s X -> s# proper X)
       (proper# head X -> proper# X, proper# natsFrom X -> proper# X)
       (proper# head X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (proper# head X -> proper# X, proper# head X -> proper# X)
       (proper# head X -> proper# X, proper# head X -> head# proper X)
       (proper# head X -> proper# X, proper# fst X -> proper# X)
       (proper# head X -> proper# X, proper# fst X -> fst# proper X)
       (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# snd X -> proper# X)
       (proper# head X -> proper# X, proper# snd X -> snd# proper X)
       (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (proper# head X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# tail X -> proper# X)
       (proper# s X -> proper# X, proper# tail X -> tail# proper X)
       (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# s X -> proper# X)
       (proper# s X -> proper# X, proper# s X -> s# proper X)
       (proper# s X -> proper# X, proper# natsFrom X -> proper# X)
       (proper# s X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (proper# s X -> proper# X, proper# head X -> proper# X)
       (proper# s X -> proper# X, proper# head X -> head# proper X)
       (proper# s X -> proper# X, proper# fst X -> proper# X)
       (proper# s X -> proper# X, proper# fst X -> fst# proper X)
       (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# snd X -> proper# X)
       (proper# s X -> proper# X, proper# snd X -> snd# proper X)
       (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# tail X -> proper# X)
       (top# mark X -> proper# X, proper# tail X -> tail# proper X)
       (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# s X -> proper# X)
       (top# mark X -> proper# X, proper# s X -> s# proper X)
       (top# mark X -> proper# X, proper# natsFrom X -> proper# X)
       (top# mark X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (top# mark X -> proper# X, proper# head X -> proper# X)
       (top# mark X -> proper# X, proper# head X -> head# proper X)
       (top# mark X -> proper# X, proper# fst X -> proper# X)
       (top# mark X -> proper# X, proper# fst X -> fst# proper X)
       (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# snd X -> proper# X)
       (top# mark X -> proper# X, proper# snd X -> snd# proper X)
       (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (active# snd X -> snd# active X, snd# ok X -> snd# X)
       (active# snd X -> snd# active X, snd# mark X -> snd# X)
       (active# head X -> head# active X, head# ok X -> head# X)
       (active# head X -> head# active X, head# mark X -> head# X)
       (active# s X -> s# active X, s# ok X -> s# X)
       (active# s X -> s# active X, s# mark X -> s# X)
       (proper# snd X -> snd# proper X, snd# ok X -> snd# X)
       (proper# snd X -> snd# proper X, snd# mark X -> snd# X)
       (proper# head X -> head# proper X, head# ok X -> head# X)
       (proper# head X -> head# proper X, head# mark X -> head# X)
       (proper# s X -> s# proper X, s# ok X -> s# X)
       (proper# s X -> s# proper X, s# mark X -> s# X)
       (top# mark X -> top# proper X, top# ok X -> top# active X)
       (top# mark X -> top# proper X, top# ok X -> active# X)
       (top# mark X -> top# proper X, top# mark X -> top# proper X)
       (top# mark X -> top# proper X, top# mark X -> proper# X)
       (active# natsFrom N -> natsFrom# s N, natsFrom# ok X -> natsFrom# X)
       (active# natsFrom N -> natsFrom# s N, natsFrom# mark X -> natsFrom# X)
       (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(mark X1, X2) -> cons#(X1, X2))
       (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(ok X1, ok X2) -> U12#(X1, X2))
       (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(mark X1, X2) -> U12#(X1, X2))
       (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
       (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
       (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, mark X2) -> pair#(X1, X2))
       (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
       (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
       (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
       (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> snd# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> fst# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> head# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> natsFrom# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> s# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> tail# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
       (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
       (top# ok X -> top# active X, top# mark X -> proper# X)
       (top# ok X -> top# active X, top# mark X -> top# proper X)
       (top# ok X -> top# active X, top# ok X -> active# X)
       (top# ok X -> top# active X, top# ok X -> top# active X)
       (proper# tail X -> tail# proper X, tail# mark X -> tail# X)
       (proper# tail X -> tail# proper X, tail# ok X -> tail# X)
       (proper# natsFrom X -> natsFrom# proper X, natsFrom# mark X -> natsFrom# X)
       (proper# natsFrom X -> natsFrom# proper X, natsFrom# ok X -> natsFrom# X)
       (proper# fst X -> fst# proper X, fst# mark X -> fst# X)
       (proper# fst X -> fst# proper X, fst# ok X -> fst# X)
       (active# tail X -> tail# active X, tail# mark X -> tail# X)
       (active# tail X -> tail# active X, tail# ok X -> tail# X)
       (active# natsFrom X -> natsFrom# active X, natsFrom# mark X -> natsFrom# X)
       (active# natsFrom X -> natsFrom# active X, natsFrom# ok X -> natsFrom# X)
       (active# fst X -> fst# active X, fst# mark X -> fst# X)
       (active# fst X -> fst# active X, fst# ok X -> fst# X)
       (top# ok X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (top# ok X -> active# X, active# U12(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (top# ok X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (top# ok X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (top# ok X -> active# X, active# pair(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# pair(X1, X2) -> active# X2)
       (top# ok X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (top# ok X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (top# ok X -> active# X, active# cons(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (top# ok X -> active# X, active# snd X -> active# X)
       (top# ok X -> active# X, active# snd X -> snd# active X)
       (top# ok X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (top# ok X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (top# ok X -> active# X, active# fst X -> active# X)
       (top# ok X -> active# X, active# fst X -> fst# active X)
       (top# ok X -> active# X, active# head X -> active# X)
       (top# ok X -> active# X, active# head X -> head# active X)
       (top# ok X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (top# ok X -> active# X, active# natsFrom N -> natsFrom# s N)
       (top# ok X -> active# X, active# natsFrom N -> s# N)
       (top# ok X -> active# X, active# natsFrom X -> active# X)
       (top# ok X -> active# X, active# natsFrom X -> natsFrom# active X)
       (top# ok X -> active# X, active# s X -> active# X)
       (top# ok X -> active# X, active# s X -> s# active X)
       (top# ok X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (top# ok X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (top# ok X -> active# X, active# sel(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# sel(X1, X2) -> active# X2)
       (top# ok X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (top# ok X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (top# ok X -> active# X, active# tail X -> active# X)
       (top# ok X -> active# X, active# tail X -> tail# active X)
       (top# ok X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (top# ok X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (top# ok X -> active# X, active# take(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# take(X1, X2) -> active# X2)
       (top# ok X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (top# ok X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (proper# tail X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# tail X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# snd X -> snd# proper X)
       (proper# tail X -> proper# X, proper# snd X -> proper# X)
       (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# fst X -> fst# proper X)
       (proper# tail X -> proper# X, proper# fst X -> proper# X)
       (proper# tail X -> proper# X, proper# head X -> head# proper X)
       (proper# tail X -> proper# X, proper# head X -> proper# X)
       (proper# tail X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (proper# tail X -> proper# X, proper# natsFrom X -> proper# X)
       (proper# tail X -> proper# X, proper# s X -> s# proper X)
       (proper# tail X -> proper# X, proper# s X -> proper# X)
       (proper# tail X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (proper# tail X -> proper# X, proper# tail X -> tail# proper X)
       (proper# tail X -> proper# X, proper# tail X -> proper# X)
       (proper# tail X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# snd X -> snd# proper X)
       (proper# natsFrom X -> proper# X, proper# snd X -> proper# X)
       (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# fst X -> fst# proper X)
       (proper# natsFrom X -> proper# X, proper# fst X -> proper# X)
       (proper# natsFrom X -> proper# X, proper# head X -> head# proper X)
       (proper# natsFrom X -> proper# X, proper# head X -> proper# X)
       (proper# natsFrom X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (proper# natsFrom X -> proper# X, proper# natsFrom X -> proper# X)
       (proper# natsFrom X -> proper# X, proper# s X -> s# proper X)
       (proper# natsFrom X -> proper# X, proper# s X -> proper# X)
       (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (proper# natsFrom X -> proper# X, proper# tail X -> tail# proper X)
       (proper# natsFrom X -> proper# X, proper# tail X -> proper# X)
       (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# fst X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# snd X -> snd# proper X)
       (proper# fst X -> proper# X, proper# snd X -> proper# X)
       (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# fst X -> fst# proper X)
       (proper# fst X -> proper# X, proper# fst X -> proper# X)
       (proper# fst X -> proper# X, proper# head X -> head# proper X)
       (proper# fst X -> proper# X, proper# head X -> proper# X)
       (proper# fst X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
       (proper# fst X -> proper# X, proper# natsFrom X -> proper# X)
       (proper# fst X -> proper# X, proper# s X -> s# proper X)
       (proper# fst X -> proper# X, proper# s X -> proper# X)
       (proper# fst X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X2)
       (proper# fst X -> proper# X, proper# tail X -> tail# proper X)
       (proper# fst X -> proper# X, proper# tail X -> proper# X)
       (proper# fst X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X1)
       (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X2)
       (tail# ok X -> tail# X, tail# mark X -> tail# X)
       (tail# ok X -> tail# X, tail# ok X -> tail# X)
       (s# ok X -> s# X, s# mark X -> s# X)
       (s# ok X -> s# X, s# ok X -> s# X)
       (natsFrom# ok X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
       (natsFrom# ok X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
       (head# ok X -> head# X, head# mark X -> head# X)
       (head# ok X -> head# X, head# ok X -> head# X)
       (fst# ok X -> fst# X, fst# mark X -> fst# X)
       (fst# ok X -> fst# X, fst# ok X -> fst# X)
       (snd# ok X -> snd# X, snd# mark X -> snd# X)
       (snd# ok X -> snd# X, snd# ok X -> snd# X)
       (active# tail X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# tail X -> active# X, active# U12(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (active# tail X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# tail X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# tail X -> active# X, active# pair(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# pair(X1, X2) -> active# X2)
       (active# tail X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# tail X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# tail X -> active# X, active# cons(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# tail X -> active# X, active# snd X -> active# X)
       (active# tail X -> active# X, active# snd X -> snd# active X)
       (active# tail X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# tail X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# tail X -> active# X, active# and(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (active# tail X -> active# X, active# fst X -> active# X)
       (active# tail X -> active# X, active# fst X -> fst# active X)
       (active# tail X -> active# X, active# head X -> active# X)
       (active# tail X -> active# X, active# head X -> head# active X)
       (active# tail X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# tail X -> active# X, active# natsFrom N -> natsFrom# s N)
       (active# tail X -> active# X, active# natsFrom N -> s# N)
       (active# tail X -> active# X, active# natsFrom X -> active# X)
       (active# tail X -> active# X, active# natsFrom X -> natsFrom# active X)
       (active# tail X -> active# X, active# s X -> active# X)
       (active# tail X -> active# X, active# s X -> s# active X)
       (active# tail X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (active# tail X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# tail X -> active# X, active# sel(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# sel(X1, X2) -> active# X2)
       (active# tail X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# tail X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# tail X -> active# X, active# tail X -> active# X)
       (active# tail X -> active# X, active# tail X -> tail# active X)
       (active# tail X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (active# tail X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# tail X -> active# X, active# take(X1, X2) -> active# X1)
       (active# tail X -> active# X, active# take(X1, X2) -> active# X2)
       (active# tail X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (active# tail X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (active# natsFrom X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# natsFrom X -> active# X, active# U12(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (active# natsFrom X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# natsFrom X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X2)
       (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# natsFrom X -> active# X, active# cons(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# natsFrom X -> active# X, active# snd X -> active# X)
       (active# natsFrom X -> active# X, active# snd X -> snd# active X)
       (active# natsFrom X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# natsFrom X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# natsFrom X -> active# X, active# and(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (active# natsFrom X -> active# X, active# fst X -> active# X)
       (active# natsFrom X -> active# X, active# fst X -> fst# active X)
       (active# natsFrom X -> active# X, active# head X -> active# X)
       (active# natsFrom X -> active# X, active# head X -> head# active X)
       (active# natsFrom X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# natsFrom X -> active# X, active# natsFrom N -> natsFrom# s N)
       (active# natsFrom X -> active# X, active# natsFrom N -> s# N)
       (active# natsFrom X -> active# X, active# natsFrom X -> active# X)
       (active# natsFrom X -> active# X, active# natsFrom X -> natsFrom# active X)
       (active# natsFrom X -> active# X, active# s X -> active# X)
       (active# natsFrom X -> active# X, active# s X -> s# active X)
       (active# natsFrom X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (active# natsFrom X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X2)
       (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# natsFrom X -> active# X, active# tail X -> active# X)
       (active# natsFrom X -> active# X, active# tail X -> tail# active X)
       (active# natsFrom X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (active# natsFrom X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X1)
       (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X2)
       (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (active# fst X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# fst X -> active# X, active# U12(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X2)
       (active# fst X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# fst X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# fst X -> active# X, active# pair(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# pair(X1, X2) -> active# X2)
       (active# fst X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# fst X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# fst X -> active# X, active# cons(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# fst X -> active# X, active# snd X -> active# X)
       (active# fst X -> active# X, active# snd X -> snd# active X)
       (active# fst X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# fst X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X2)
       (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# fst X -> active# X, active# and(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (active# fst X -> active# X, active# fst X -> active# X)
       (active# fst X -> active# X, active# fst X -> fst# active X)
       (active# fst X -> active# X, active# head X -> active# X)
       (active# fst X -> active# X, active# head X -> head# active X)
       (active# fst X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# fst X -> active# X, active# natsFrom N -> natsFrom# s N)
       (active# fst X -> active# X, active# natsFrom N -> s# N)
       (active# fst X -> active# X, active# natsFrom X -> active# X)
       (active# fst X -> active# X, active# natsFrom X -> natsFrom# active X)
       (active# fst X -> active# X, active# s X -> active# X)
       (active# fst X -> active# X, active# s X -> s# active X)
       (active# fst X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
       (active# fst X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# fst X -> active# X, active# sel(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# sel(X1, X2) -> active# X2)
       (active# fst X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# fst X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# fst X -> active# X, active# tail X -> active# X)
       (active# fst X -> active# X, active# tail X -> tail# active X)
       (active# fst X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
       (active# fst X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# fst X -> active# X, active# take(X1, X2) -> active# X1)
       (active# fst X -> active# X, active# take(X1, X2) -> active# X2)
       (active# fst X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
       (active# fst X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
       (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(X1, mark X2) -> take#(X1, X2))
       (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(mark X1, X2) -> take#(X1, X2))
       (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(ok X1, ok X2) -> take#(X1, X2))
       (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
       (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(mark X1, X2) -> cons#(X1, X2))
       (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
       (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
       (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
       (active# take(X1, X2) -> take#(X1, active X2), take#(X1, mark X2) -> take#(X1, X2))
       (active# take(X1, X2) -> take#(X1, active X2), take#(mark X1, X2) -> take#(X1, X2))
       (active# take(X1, X2) -> take#(X1, active X2), take#(ok X1, ok X2) -> take#(X1, X2))
       (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
       (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
       (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
       (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
       (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
       (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
       (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# take(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# take(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# take(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# take(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# take(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# take(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# take(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# take(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> head# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> s# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> proper# X)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
       (proper# U12(X1, X2) -> proper# X1, proper# snd X -> proper# X)
       (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
       (proper# U12(X1, X2) -> proper# X1, proper# fst X -> proper# X)
       (proper# U12(X1, X2) -> proper# X1, proper# head X -> head# proper X)
       (proper# U12(X1, X2) -> proper# X1, proper# head X -> proper# X)
       (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
       (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
       (proper# U12(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# U12(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
       (proper# U12(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
       (proper# U12(X1, X2) -> proper# X1, proper# tail X -> proper# X)
       (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
       (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
       (active# take(N, XS) -> fst# splitAt(N, XS), fst# mark X -> fst# X)
       (active# take(N, XS) -> fst# splitAt(N, XS), fst# ok X -> fst# X)
       (active# sel(N, XS) -> head# afterNth(N, XS), head# mark X -> head# X)
       (active# sel(N, XS) -> head# afterNth(N, XS), head# ok X -> head# X)
       (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# afterNth(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# afterNth(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# afterNth(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# afterNth(X1, X2) -> active# X1, active# head X -> active# X)
       (active# afterNth(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# afterNth(X1, X2) -> active# X1, active# s X -> active# X)
       (active# afterNth(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# afterNth(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# cons(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# cons(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# cons(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# cons(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# cons(X1, X2) -> active# X1, active# head X -> active# X)
       (active# cons(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# cons(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# cons(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# cons(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# cons(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# cons(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# cons(X1, X2) -> active# X1, active# s X -> active# X)
       (active# cons(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# cons(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# cons(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> active# X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> snd# active X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> active# X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> fst# active X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> active# X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> head# active X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> s# N)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> active# X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> active# X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> s# active X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> active# X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> tail# active X)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
       (active# U12(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# U12(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
       (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# snd X -> active# X)
       (active# U12(X1, X2) -> active# X1, active# snd X -> snd# active X)
       (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
       (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# fst X -> active# X)
       (active# U12(X1, X2) -> active# X1, active# fst X -> fst# active X)
       (active# U12(X1, X2) -> active# X1, active# head X -> active# X)
       (active# U12(X1, X2) -> active# X1, active# head X -> head# active X)
       (active# U12(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# U12(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
       (active# U12(X1, X2) -> active# X1, active# natsFrom N -> s# N)
       (active# U12(X1, X2) -> active# X1, active# natsFrom X -> active# X)
       (active# U12(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
       (active# U12(X1, X2) -> active# X1, active# s X -> active# X)
       (active# U12(X1, X2) -> active# X1, active# s X -> s# active X)
       (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
       (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
       (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# U12(X1, X2) -> active# X1, active# tail X -> active# X)
       (active# U12(X1, X2) -> active# X1, active# tail X -> tail# active X)
       (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
       (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
       (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
       (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
       (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
       (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
       (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
       (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
       (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
       (take#(mark X1, X2) -> take#(X1, X2), take#(X1, mark 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#(ok X1, ok X2) -> take#(X1, X2))
       (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
       (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
       (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(mark X1, X2) -> sel#(X1, X2))
       (sel#(X1, mark X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
       (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
       (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
       (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
       (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
       (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
       (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(mark X1, X2) -> pair#(X1, X2))
       (pair#(X1, mark X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
       (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark 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#(ok X1, ok X2) -> splitAt#(X1, X2))
       (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
       (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(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#(ok X1, ok X2) -> cons#(X1, X2))
       (active# take(X1, X2) -> take#(active X1, X2), take#(X1, mark X2) -> take#(X1, X2))
       (active# take(X1, X2) -> take#(active X1, X2), take#(mark X1, X2) -> take#(X1, X2))
       (active# take(X1, X2) -> take#(active X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
       (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
       (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (active# cons(X1, X2) -> cons#(active X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
       (active# cons(X1, X2) -> cons#(active X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
       (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
       (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
       (active# natsFrom N -> s# N, s# mark X -> s# X)
       (active# natsFrom N -> s# N, s# ok X -> s# X)
       (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# sel(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# sel(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# sel(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# sel(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# sel(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# sel(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# sel(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# sel(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# pair(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# pair(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# pair(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# pair(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# pair(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# pair(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# pair(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
       (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
       (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
       (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> head# proper X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
       (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> proper# X)
       (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
       (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
       (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
       (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# take(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# snd X -> active# X)
       (active# take(X1, X2) -> active# X2, active# snd X -> snd# active X)
       (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# fst X -> active# X)
       (active# take(X1, X2) -> active# X2, active# fst X -> fst# active X)
       (active# take(X1, X2) -> active# X2, active# head X -> active# X)
       (active# take(X1, X2) -> active# X2, active# head X -> head# active X)
       (active# take(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# take(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
       (active# take(X1, X2) -> active# X2, active# natsFrom N -> s# N)
       (active# take(X1, X2) -> active# X2, active# natsFrom X -> active# X)
       (active# take(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
       (active# take(X1, X2) -> active# X2, active# s X -> active# X)
       (active# take(X1, X2) -> active# X2, active# s X -> s# active X)
       (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
       (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# take(X1, X2) -> active# X2, active# tail X -> active# X)
       (active# take(X1, X2) -> active# X2, active# tail X -> tail# active X)
       (active# take(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
       (active# take(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
       (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
       (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
       (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# afterNth(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# snd X -> active# X)
       (active# afterNth(X1, X2) -> active# X2, active# snd X -> snd# active X)
       (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# fst X -> active# X)
       (active# afterNth(X1, X2) -> active# X2, active# fst X -> fst# active X)
       (active# afterNth(X1, X2) -> active# X2, active# head X -> active# X)
       (active# afterNth(X1, X2) -> active# X2, active# head X -> head# active X)
       (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
       (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> s# N)
       (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> active# X)
       (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
       (active# afterNth(X1, X2) -> active# X2, active# s X -> active# X)
       (active# afterNth(X1, X2) -> active# X2, active# s X -> s# active X)
       (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# afterNth(X1, X2) -> active# X2, active# tail X -> active# X)
       (active# afterNth(X1, X2) -> active# X2, active# tail X -> tail# active X)
       (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
       (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
       (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
       (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
       (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
       (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
       (active# splitAt(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
       (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
       (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
       (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# snd X -> active# X)
       (active# splitAt(X1, X2) -> active# X2, active# snd X -> snd# active X)
       (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# fst X -> active# X)
       (active# splitAt(X1, X2) -> active# X2, active# fst X -> fst# active X)
       (active# splitAt(X1, X2) -> active# X2, active# head X -> active# X)
       (active# splitAt(X1, X2) -> active# X2, active# head X -> head# active X)
       (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
       (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
       (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> s# N)
       (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> active# X)
       (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
       (active# splitAt(X1, X2) -> active# X2, active# s X -> active# X)
       (active# splitAt(X1, X2) -> active# X2, active# s X -> s# active X)
       (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
       (active# splitAt(X1, X2) -> active# X2, active# tail X -> active# X)
       (active# splitAt(X1, X2) -> active# X2, active# tail X -> tail# active X)
       (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
       (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
       (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
       (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
       (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
      }
      EDG:
       {
        (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
        (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# pair(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
        (active# pair(X1, X2) -> active# X2, active# tail X -> tail# active X)
        (active# pair(X1, X2) -> active# X2, active# tail X -> active# X)
        (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# pair(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
        (active# pair(X1, X2) -> active# X2, active# s X -> s# active X)
        (active# pair(X1, X2) -> active# X2, active# s X -> active# X)
        (active# pair(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
        (active# pair(X1, X2) -> active# X2, active# natsFrom X -> active# X)
        (active# pair(X1, X2) -> active# X2, active# natsFrom N -> s# N)
        (active# pair(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
        (active# pair(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# pair(X1, X2) -> active# X2, active# head X -> head# active X)
        (active# pair(X1, X2) -> active# X2, active# head X -> active# X)
        (active# pair(X1, X2) -> active# X2, active# fst X -> fst# active X)
        (active# pair(X1, X2) -> active# X2, active# fst X -> active# X)
        (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# pair(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# pair(X1, X2) -> active# X2, active# snd X -> snd# active X)
        (active# pair(X1, X2) -> active# X2, active# snd X -> active# X)
        (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# pair(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# pair(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# pair(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# pair(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# pair(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
        (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# sel(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
        (active# sel(X1, X2) -> active# X2, active# tail X -> tail# active X)
        (active# sel(X1, X2) -> active# X2, active# tail X -> active# X)
        (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# sel(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
        (active# sel(X1, X2) -> active# X2, active# s X -> s# active X)
        (active# sel(X1, X2) -> active# X2, active# s X -> active# X)
        (active# sel(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
        (active# sel(X1, X2) -> active# X2, active# natsFrom X -> active# X)
        (active# sel(X1, X2) -> active# X2, active# natsFrom N -> s# N)
        (active# sel(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
        (active# sel(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# sel(X1, X2) -> active# X2, active# head X -> head# active X)
        (active# sel(X1, X2) -> active# X2, active# head X -> active# X)
        (active# sel(X1, X2) -> active# X2, active# fst X -> fst# active X)
        (active# sel(X1, X2) -> active# X2, active# fst X -> active# X)
        (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# sel(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# sel(X1, X2) -> active# X2, active# snd X -> snd# active X)
        (active# sel(X1, X2) -> active# X2, active# snd X -> active# X)
        (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# sel(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# sel(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# sel(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# sel(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# sel(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
        (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# U12(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# U12(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# U12(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# U12(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# U12(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# U12(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# U12(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# U12(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# s X -> s# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# head X -> head# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# take(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# take(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# take(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# take(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# take(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# take(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# take(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# take(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (active# U12(X1, X2) -> U12#(active X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
        (active# U12(X1, X2) -> U12#(active X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
        (active# pair(X1, X2) -> pair#(active X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
        (active# pair(X1, X2) -> pair#(active X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
        (active# pair(X1, X2) -> pair#(active X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
        (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
        (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
        (active# afterNth(X1, X2) -> afterNth#(active X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
        (active# sel(X1, X2) -> sel#(active X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
        (active# sel(X1, X2) -> sel#(active X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
        (active# sel(X1, X2) -> sel#(active X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
        (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(ok X1, ok X2) -> pair#(X1, X2))
        (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(mark X1, X2) -> pair#(X1, X2))
        (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(X1, mark X2) -> pair#(X1, X2))
        (U12#(mark X1, X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
        (U12#(mark X1, X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
        (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
        (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
        (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
        (splitAt#(ok X1, ok X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
        (pair#(mark X1, X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(X1, mark X2) -> pair#(X1, X2))
        (cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
        (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok 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#(X1, mark X2) -> afterNth#(X1, X2))
        (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
        (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
        (afterNth#(ok X1, ok X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
        (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
        (sel#(mark X1, X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(X1, mark X2) -> sel#(X1, X2))
        (take#(X1, mark X2) -> take#(X1, X2), take#(ok X1, ok 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#(X1, mark X2) -> take#(X1, X2))
        (take#(ok X1, ok X2) -> take#(X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
        (take#(ok X1, ok X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2))
        (take#(ok X1, ok X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
        (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
        (active# take(N, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok 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#(X1, mark X2) -> splitAt#(X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# splitAt(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# splitAt(X1, X2) -> active# X1, active# s X -> active# X)
        (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# splitAt(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# splitAt(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# splitAt(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# splitAt(X1, X2) -> active# X1, active# head X -> active# X)
        (active# splitAt(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# splitAt(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# splitAt(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# splitAt(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# splitAt(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# splitAt(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# splitAt(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# pair(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# pair(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# pair(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# pair(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# pair(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# pair(X1, X2) -> active# X1, active# s X -> active# X)
        (active# pair(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# pair(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# pair(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# pair(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# pair(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# pair(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# pair(X1, X2) -> active# X1, active# head X -> active# X)
        (active# pair(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# pair(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# pair(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# pair(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# pair(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# pair(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# pair(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# pair(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# pair(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# pair(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# pair(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# ok X -> snd# X)
        (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# mark X -> snd# X)
        (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# and(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# and(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# and(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# and(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# and(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# and(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# and(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# and(X1, X2) -> active# X1, active# s X -> active# X)
        (active# and(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# and(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# and(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# and(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# and(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# and(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# and(X1, X2) -> active# X1, active# head X -> active# X)
        (active# and(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# and(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# and(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# and(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# and(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# and(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# and(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# and(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# and(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# and(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# and(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# sel(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# sel(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# sel(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# sel(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# sel(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# sel(X1, X2) -> active# X1, active# s X -> active# X)
        (active# sel(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# sel(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# sel(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# sel(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# sel(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# sel(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# sel(X1, X2) -> active# X1, active# head X -> active# X)
        (active# sel(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# sel(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# sel(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# sel(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# sel(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# sel(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# sel(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# sel(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# sel(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# sel(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# sel(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# take(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# take(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# take(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# take(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# take(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# take(X1, X2) -> active# X1, active# s X -> active# X)
        (active# take(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# take(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# take(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# take(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# take(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# take(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# take(X1, X2) -> active# X1, active# head X -> active# X)
        (active# take(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# take(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# take(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# take(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# take(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# take(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# take(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# take(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# take(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# take(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# pair(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# pair(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# pair(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# pair(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# pair(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# pair(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# pair(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# pair(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# sel(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# sel(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# sel(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# sel(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# sel(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# sel(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# sel(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# sel(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# tail X -> tail# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# s X -> s# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# natsFrom X -> natsFrom# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# head X -> head# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# fst X -> fst# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# snd X -> snd# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X4, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (active# pair(X1, X2) -> pair#(X1, active X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
        (active# pair(X1, X2) -> pair#(X1, active X2), pair#(mark X1, X2) -> pair#(X1, X2))
        (active# pair(X1, X2) -> pair#(X1, active X2), pair#(X1, mark X2) -> pair#(X1, X2))
        (active# sel(X1, X2) -> sel#(X1, active X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
        (active# sel(X1, X2) -> sel#(X1, active X2), sel#(mark X1, X2) -> sel#(X1, X2))
        (active# sel(X1, X2) -> sel#(X1, active X2), sel#(X1, mark X2) -> sel#(X1, X2))
        (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(ok X1, ok X2) -> U12#(X1, X2))
        (proper# U12(X1, X2) -> U12#(proper X1, proper X2), U12#(mark X1, X2) -> U12#(X1, X2))
        (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
        (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(mark X1, X2) -> pair#(X1, X2))
        (proper# pair(X1, X2) -> pair#(proper X1, proper X2), pair#(X1, mark X2) -> pair#(X1, X2))
        (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
        (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
        (proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
        (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
        (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(mark X1, X2) -> sel#(X1, X2))
        (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(X1, mark X2) -> sel#(X1, X2))
        (active# snd X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (active# snd X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (active# snd X -> active# X, active# take(X1, X2) -> active# X2)
        (active# snd X -> active# X, active# take(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# snd X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (active# snd X -> active# X, active# tail X -> tail# active X)
        (active# snd X -> active# X, active# tail X -> active# X)
        (active# snd X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# snd X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# snd X -> active# X, active# sel(X1, X2) -> active# X2)
        (active# snd X -> active# X, active# sel(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# snd X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (active# snd X -> active# X, active# s X -> s# active X)
        (active# snd X -> active# X, active# s X -> active# X)
        (active# snd X -> active# X, active# natsFrom X -> natsFrom# active X)
        (active# snd X -> active# X, active# natsFrom X -> active# X)
        (active# snd X -> active# X, active# natsFrom N -> s# N)
        (active# snd X -> active# X, active# natsFrom N -> natsFrom# s N)
        (active# snd X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# snd X -> active# X, active# head X -> head# active X)
        (active# snd X -> active# X, active# head X -> active# X)
        (active# snd X -> active# X, active# fst X -> fst# active X)
        (active# snd X -> active# X, active# fst X -> active# X)
        (active# snd X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (active# snd X -> active# X, active# and(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# snd X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (active# snd X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# snd X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# snd X -> active# X, active# snd X -> snd# active X)
        (active# snd X -> active# X, active# snd X -> active# X)
        (active# snd X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# snd X -> active# X, active# cons(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# snd X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# snd X -> active# X, active# pair(X1, X2) -> active# X2)
        (active# snd X -> active# X, active# pair(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# snd X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# snd X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# snd X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# snd X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (active# snd X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# snd X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# snd X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# snd X -> active# X, active# U12(X1, X2) -> active# X1)
        (active# snd X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# head X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (active# head X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (active# head X -> active# X, active# take(X1, X2) -> active# X2)
        (active# head X -> active# X, active# take(X1, X2) -> active# X1)
        (active# head X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# head X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (active# head X -> active# X, active# tail X -> tail# active X)
        (active# head X -> active# X, active# tail X -> active# X)
        (active# head X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# head X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# head X -> active# X, active# sel(X1, X2) -> active# X2)
        (active# head X -> active# X, active# sel(X1, X2) -> active# X1)
        (active# head X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# head X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (active# head X -> active# X, active# s X -> s# active X)
        (active# head X -> active# X, active# s X -> active# X)
        (active# head X -> active# X, active# natsFrom X -> natsFrom# active X)
        (active# head X -> active# X, active# natsFrom X -> active# X)
        (active# head X -> active# X, active# natsFrom N -> s# N)
        (active# head X -> active# X, active# natsFrom N -> natsFrom# s N)
        (active# head X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# head X -> active# X, active# head X -> head# active X)
        (active# head X -> active# X, active# head X -> active# X)
        (active# head X -> active# X, active# fst X -> fst# active X)
        (active# head X -> active# X, active# fst X -> active# X)
        (active# head X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (active# head X -> active# X, active# and(X1, X2) -> active# X1)
        (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# head X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# head X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (active# head X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (active# head X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# head X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# head X -> active# X, active# snd X -> snd# active X)
        (active# head X -> active# X, active# snd X -> active# X)
        (active# head X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# head X -> active# X, active# cons(X1, X2) -> active# X1)
        (active# head X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# head X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# head X -> active# X, active# pair(X1, X2) -> active# X2)
        (active# head X -> active# X, active# pair(X1, X2) -> active# X1)
        (active# head X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# head X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# head X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# head X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# head X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# head X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (active# head X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# head X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# head X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# head X -> active# X, active# U12(X1, X2) -> active# X1)
        (active# head X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# s X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (active# s X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (active# s X -> active# X, active# take(X1, X2) -> active# X2)
        (active# s X -> active# X, active# take(X1, X2) -> active# X1)
        (active# s X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# s X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (active# s X -> active# X, active# tail X -> tail# active X)
        (active# s X -> active# X, active# tail X -> active# X)
        (active# s X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# s X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# s X -> active# X, active# sel(X1, X2) -> active# X2)
        (active# s X -> active# X, active# sel(X1, X2) -> active# X1)
        (active# s X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# s X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (active# s X -> active# X, active# s X -> s# active X)
        (active# s X -> active# X, active# s X -> active# X)
        (active# s X -> active# X, active# natsFrom X -> natsFrom# active X)
        (active# s X -> active# X, active# natsFrom X -> active# X)
        (active# s X -> active# X, active# natsFrom N -> s# N)
        (active# s X -> active# X, active# natsFrom N -> natsFrom# s N)
        (active# s X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# s X -> active# X, active# head X -> head# active X)
        (active# s X -> active# X, active# head X -> active# X)
        (active# s X -> active# X, active# fst X -> fst# active X)
        (active# s X -> active# X, active# fst X -> active# X)
        (active# s X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (active# s X -> active# X, active# and(X1, X2) -> active# X1)
        (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# s X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# s X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (active# s X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (active# s X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# s X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# s X -> active# X, active# snd X -> snd# active X)
        (active# s X -> active# X, active# snd X -> active# X)
        (active# s X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# s X -> active# X, active# cons(X1, X2) -> active# X1)
        (active# s X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# s X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# s X -> active# X, active# pair(X1, X2) -> active# X2)
        (active# s X -> active# X, active# pair(X1, X2) -> active# X1)
        (active# s X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# s X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# s X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# s X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# s X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# s X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (active# s X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# s X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# s X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# s X -> active# X, active# U12(X1, X2) -> active# X1)
        (active# s X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (snd# mark X -> snd# X, snd# ok X -> snd# X)
        (snd# mark X -> snd# X, snd# mark X -> snd# X)
        (fst# mark X -> fst# X, fst# ok X -> fst# X)
        (fst# mark X -> fst# X, fst# mark X -> fst# X)
        (head# mark X -> head# X, head# ok X -> head# X)
        (head# mark X -> head# X, head# mark X -> head# X)
        (natsFrom# mark X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
        (natsFrom# mark X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
        (s# mark X -> s# X, s# ok X -> s# X)
        (s# mark X -> s# X, s# mark X -> s# X)
        (tail# mark X -> tail# X, tail# ok X -> tail# X)
        (tail# mark X -> tail# X, tail# mark X -> tail# X)
        (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# tail X -> proper# X)
        (proper# snd X -> proper# X, proper# tail X -> tail# proper X)
        (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# s X -> proper# X)
        (proper# snd X -> proper# X, proper# s X -> s# proper X)
        (proper# snd X -> proper# X, proper# natsFrom X -> proper# X)
        (proper# snd X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (proper# snd X -> proper# X, proper# head X -> proper# X)
        (proper# snd X -> proper# X, proper# head X -> head# proper X)
        (proper# snd X -> proper# X, proper# fst X -> proper# X)
        (proper# snd X -> proper# X, proper# fst X -> fst# proper X)
        (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# snd X -> proper# X)
        (proper# snd X -> proper# X, proper# snd X -> snd# proper X)
        (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# snd X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (proper# snd X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (proper# snd X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# tail X -> proper# X)
        (proper# head X -> proper# X, proper# tail X -> tail# proper X)
        (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# s X -> proper# X)
        (proper# head X -> proper# X, proper# s X -> s# proper X)
        (proper# head X -> proper# X, proper# natsFrom X -> proper# X)
        (proper# head X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (proper# head X -> proper# X, proper# head X -> proper# X)
        (proper# head X -> proper# X, proper# head X -> head# proper X)
        (proper# head X -> proper# X, proper# fst X -> proper# X)
        (proper# head X -> proper# X, proper# fst X -> fst# proper X)
        (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# snd X -> proper# X)
        (proper# head X -> proper# X, proper# snd X -> snd# proper X)
        (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# head X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (proper# head X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (proper# head X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# tail X -> proper# X)
        (proper# s X -> proper# X, proper# tail X -> tail# proper X)
        (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# s X -> proper# X)
        (proper# s X -> proper# X, proper# s X -> s# proper X)
        (proper# s X -> proper# X, proper# natsFrom X -> proper# X)
        (proper# s X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (proper# s X -> proper# X, proper# head X -> proper# X)
        (proper# s X -> proper# X, proper# head X -> head# proper X)
        (proper# s X -> proper# X, proper# fst X -> proper# X)
        (proper# s X -> proper# X, proper# fst X -> fst# proper X)
        (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# snd X -> proper# X)
        (proper# s X -> proper# X, proper# snd X -> snd# proper X)
        (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# s X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# tail X -> proper# X)
        (top# mark X -> proper# X, proper# tail X -> tail# proper X)
        (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# s X -> proper# X)
        (top# mark X -> proper# X, proper# s X -> s# proper X)
        (top# mark X -> proper# X, proper# natsFrom X -> proper# X)
        (top# mark X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (top# mark X -> proper# X, proper# head X -> proper# X)
        (top# mark X -> proper# X, proper# head X -> head# proper X)
        (top# mark X -> proper# X, proper# fst X -> proper# X)
        (top# mark X -> proper# X, proper# fst X -> fst# proper X)
        (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# snd X -> proper# X)
        (top# mark X -> proper# X, proper# snd X -> snd# proper X)
        (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (top# mark X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (active# snd X -> snd# active X, snd# ok X -> snd# X)
        (active# snd X -> snd# active X, snd# mark X -> snd# X)
        (active# head X -> head# active X, head# ok X -> head# X)
        (active# head X -> head# active X, head# mark X -> head# X)
        (active# s X -> s# active X, s# ok X -> s# X)
        (active# s X -> s# active X, s# mark X -> s# X)
        (proper# snd X -> snd# proper X, snd# ok X -> snd# X)
        (proper# snd X -> snd# proper X, snd# mark X -> snd# X)
        (proper# head X -> head# proper X, head# ok X -> head# X)
        (proper# head X -> head# proper X, head# mark X -> head# X)
        (proper# s X -> s# proper X, s# ok X -> s# X)
        (proper# s X -> s# proper X, s# mark X -> s# X)
        (top# mark X -> top# proper X, top# ok X -> top# active X)
        (top# mark X -> top# proper X, top# ok X -> active# X)
        (top# mark X -> top# proper X, top# mark X -> top# proper X)
        (top# mark X -> top# proper X, top# mark X -> proper# X)
        (active# natsFrom N -> natsFrom# s N, natsFrom# ok X -> natsFrom# X)
        (active# natsFrom N -> natsFrom# s N, natsFrom# mark X -> natsFrom# X)
        (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(mark X1, X2) -> cons#(X1, X2))
        (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(ok X1, ok X2) -> U12#(X1, X2))
        (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(mark X1, X2) -> U12#(X1, X2))
        (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
        (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
        (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, mark X2) -> pair#(X1, X2))
        (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
        (U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
        (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
        (active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U12(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# splitAt(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# pair(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> snd# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# snd X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# afterNth(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# and(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> fst# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# fst X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> head# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# head X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> natsFrom# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# natsFrom X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> s# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# s X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# sel(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> tail# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# tail X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X3, proper# take(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
        (proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4), U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4))
        (top# ok X -> top# active X, top# mark X -> proper# X)
        (top# ok X -> top# active X, top# mark X -> top# proper X)
        (top# ok X -> top# active X, top# ok X -> active# X)
        (top# ok X -> top# active X, top# ok X -> top# active X)
        (proper# tail X -> tail# proper X, tail# mark X -> tail# X)
        (proper# tail X -> tail# proper X, tail# ok X -> tail# X)
        (proper# natsFrom X -> natsFrom# proper X, natsFrom# mark X -> natsFrom# X)
        (proper# natsFrom X -> natsFrom# proper X, natsFrom# ok X -> natsFrom# X)
        (proper# fst X -> fst# proper X, fst# mark X -> fst# X)
        (proper# fst X -> fst# proper X, fst# ok X -> fst# X)
        (active# tail X -> tail# active X, tail# mark X -> tail# X)
        (active# tail X -> tail# active X, tail# ok X -> tail# X)
        (active# natsFrom X -> natsFrom# active X, natsFrom# mark X -> natsFrom# X)
        (active# natsFrom X -> natsFrom# active X, natsFrom# ok X -> natsFrom# X)
        (active# fst X -> fst# active X, fst# mark X -> fst# X)
        (active# fst X -> fst# active X, fst# ok X -> fst# X)
        (top# ok X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (top# ok X -> active# X, active# U12(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (top# ok X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (top# ok X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (top# ok X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (top# ok X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (top# ok X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (top# ok X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (top# ok X -> active# X, active# pair(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# pair(X1, X2) -> active# X2)
        (top# ok X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (top# ok X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (top# ok X -> active# X, active# cons(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (top# ok X -> active# X, active# snd X -> active# X)
        (top# ok X -> active# X, active# snd X -> snd# active X)
        (top# ok X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (top# ok X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (top# ok X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (top# ok X -> active# X, active# fst X -> active# X)
        (top# ok X -> active# X, active# fst X -> fst# active X)
        (top# ok X -> active# X, active# head X -> active# X)
        (top# ok X -> active# X, active# head X -> head# active X)
        (top# ok X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (top# ok X -> active# X, active# natsFrom N -> natsFrom# s N)
        (top# ok X -> active# X, active# natsFrom N -> s# N)
        (top# ok X -> active# X, active# natsFrom X -> active# X)
        (top# ok X -> active# X, active# natsFrom X -> natsFrom# active X)
        (top# ok X -> active# X, active# s X -> active# X)
        (top# ok X -> active# X, active# s X -> s# active X)
        (top# ok X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (top# ok X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (top# ok X -> active# X, active# sel(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# sel(X1, X2) -> active# X2)
        (top# ok X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (top# ok X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (top# ok X -> active# X, active# tail X -> active# X)
        (top# ok X -> active# X, active# tail X -> tail# active X)
        (top# ok X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (top# ok X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (top# ok X -> active# X, active# take(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# take(X1, X2) -> active# X2)
        (top# ok X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (top# ok X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (proper# tail X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# tail X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# tail X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# snd X -> snd# proper X)
        (proper# tail X -> proper# X, proper# snd X -> proper# X)
        (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# fst X -> fst# proper X)
        (proper# tail X -> proper# X, proper# fst X -> proper# X)
        (proper# tail X -> proper# X, proper# head X -> head# proper X)
        (proper# tail X -> proper# X, proper# head X -> proper# X)
        (proper# tail X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (proper# tail X -> proper# X, proper# natsFrom X -> proper# X)
        (proper# tail X -> proper# X, proper# s X -> s# proper X)
        (proper# tail X -> proper# X, proper# s X -> proper# X)
        (proper# tail X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (proper# tail X -> proper# X, proper# tail X -> tail# proper X)
        (proper# tail X -> proper# X, proper# tail X -> proper# X)
        (proper# tail X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (proper# tail X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# natsFrom X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# snd X -> snd# proper X)
        (proper# natsFrom X -> proper# X, proper# snd X -> proper# X)
        (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# fst X -> fst# proper X)
        (proper# natsFrom X -> proper# X, proper# fst X -> proper# X)
        (proper# natsFrom X -> proper# X, proper# head X -> head# proper X)
        (proper# natsFrom X -> proper# X, proper# head X -> proper# X)
        (proper# natsFrom X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (proper# natsFrom X -> proper# X, proper# natsFrom X -> proper# X)
        (proper# natsFrom X -> proper# X, proper# s X -> s# proper X)
        (proper# natsFrom X -> proper# X, proper# s X -> proper# X)
        (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (proper# natsFrom X -> proper# X, proper# tail X -> tail# proper X)
        (proper# natsFrom X -> proper# X, proper# tail X -> proper# X)
        (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (proper# natsFrom X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# U12(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# splitAt(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# fst X -> proper# X, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# fst X -> proper# X, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# pair(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# snd X -> snd# proper X)
        (proper# fst X -> proper# X, proper# snd X -> proper# X)
        (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# afterNth(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# fst X -> fst# proper X)
        (proper# fst X -> proper# X, proper# fst X -> proper# X)
        (proper# fst X -> proper# X, proper# head X -> head# proper X)
        (proper# fst X -> proper# X, proper# head X -> proper# X)
        (proper# fst X -> proper# X, proper# natsFrom X -> natsFrom# proper X)
        (proper# fst X -> proper# X, proper# natsFrom X -> proper# X)
        (proper# fst X -> proper# X, proper# s X -> s# proper X)
        (proper# fst X -> proper# X, proper# s X -> proper# X)
        (proper# fst X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# sel(X1, X2) -> proper# X2)
        (proper# fst X -> proper# X, proper# tail X -> tail# proper X)
        (proper# fst X -> proper# X, proper# tail X -> proper# X)
        (proper# fst X -> proper# X, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X1)
        (proper# fst X -> proper# X, proper# take(X1, X2) -> proper# X2)
        (tail# ok X -> tail# X, tail# mark X -> tail# X)
        (tail# ok X -> tail# X, tail# ok X -> tail# X)
        (s# ok X -> s# X, s# mark X -> s# X)
        (s# ok X -> s# X, s# ok X -> s# X)
        (natsFrom# ok X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
        (natsFrom# ok X -> natsFrom# X, natsFrom# ok X -> natsFrom# X)
        (head# ok X -> head# X, head# mark X -> head# X)
        (head# ok X -> head# X, head# ok X -> head# X)
        (fst# ok X -> fst# X, fst# mark X -> fst# X)
        (fst# ok X -> fst# X, fst# ok X -> fst# X)
        (snd# ok X -> snd# X, snd# mark X -> snd# X)
        (snd# ok X -> snd# X, snd# ok X -> snd# X)
        (active# tail X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# tail X -> active# X, active# U12(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# tail X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# tail X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (active# tail X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# tail X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# tail X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# tail X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# tail X -> active# X, active# pair(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# pair(X1, X2) -> active# X2)
        (active# tail X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# tail X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# tail X -> active# X, active# cons(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# tail X -> active# X, active# snd X -> active# X)
        (active# tail X -> active# X, active# snd X -> snd# active X)
        (active# tail X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# tail X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# tail X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# tail X -> active# X, active# and(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (active# tail X -> active# X, active# fst X -> active# X)
        (active# tail X -> active# X, active# fst X -> fst# active X)
        (active# tail X -> active# X, active# head X -> active# X)
        (active# tail X -> active# X, active# head X -> head# active X)
        (active# tail X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# tail X -> active# X, active# natsFrom N -> natsFrom# s N)
        (active# tail X -> active# X, active# natsFrom N -> s# N)
        (active# tail X -> active# X, active# natsFrom X -> active# X)
        (active# tail X -> active# X, active# natsFrom X -> natsFrom# active X)
        (active# tail X -> active# X, active# s X -> active# X)
        (active# tail X -> active# X, active# s X -> s# active X)
        (active# tail X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (active# tail X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# tail X -> active# X, active# sel(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# sel(X1, X2) -> active# X2)
        (active# tail X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# tail X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# tail X -> active# X, active# tail X -> active# X)
        (active# tail X -> active# X, active# tail X -> tail# active X)
        (active# tail X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (active# tail X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# tail X -> active# X, active# take(X1, X2) -> active# X1)
        (active# tail X -> active# X, active# take(X1, X2) -> active# X2)
        (active# tail X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (active# tail X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (active# natsFrom X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# natsFrom X -> active# X, active# U12(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# natsFrom X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (active# natsFrom X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# natsFrom X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# natsFrom X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# natsFrom X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# pair(X1, X2) -> active# X2)
        (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# natsFrom X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# natsFrom X -> active# X, active# cons(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# natsFrom X -> active# X, active# snd X -> active# X)
        (active# natsFrom X -> active# X, active# snd X -> snd# active X)
        (active# natsFrom X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# natsFrom X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# natsFrom X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# natsFrom X -> active# X, active# and(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (active# natsFrom X -> active# X, active# fst X -> active# X)
        (active# natsFrom X -> active# X, active# fst X -> fst# active X)
        (active# natsFrom X -> active# X, active# head X -> active# X)
        (active# natsFrom X -> active# X, active# head X -> head# active X)
        (active# natsFrom X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# natsFrom X -> active# X, active# natsFrom N -> natsFrom# s N)
        (active# natsFrom X -> active# X, active# natsFrom N -> s# N)
        (active# natsFrom X -> active# X, active# natsFrom X -> active# X)
        (active# natsFrom X -> active# X, active# natsFrom X -> natsFrom# active X)
        (active# natsFrom X -> active# X, active# s X -> active# X)
        (active# natsFrom X -> active# X, active# s X -> s# active X)
        (active# natsFrom X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (active# natsFrom X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# sel(X1, X2) -> active# X2)
        (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# natsFrom X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# natsFrom X -> active# X, active# tail X -> active# X)
        (active# natsFrom X -> active# X, active# tail X -> tail# active X)
        (active# natsFrom X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (active# natsFrom X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X1)
        (active# natsFrom X -> active# X, active# take(X1, X2) -> active# X2)
        (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (active# natsFrom X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (active# fst X -> active# X, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# fst X -> active# X, active# U12(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# fst X -> active# X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# fst X -> active# X, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# splitAt(X1, X2) -> active# X2)
        (active# fst X -> active# X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# fst X -> active# X, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# fst X -> active# X, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# fst X -> active# X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# fst X -> active# X, active# pair(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# pair(X1, X2) -> active# X2)
        (active# fst X -> active# X, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# fst X -> active# X, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# fst X -> active# X, active# cons(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# fst X -> active# X, active# snd X -> active# X)
        (active# fst X -> active# X, active# snd X -> snd# active X)
        (active# fst X -> active# X, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# fst X -> active# X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# afterNth(X1, X2) -> active# X2)
        (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# fst X -> active# X, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# fst X -> active# X, active# and(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (active# fst X -> active# X, active# fst X -> active# X)
        (active# fst X -> active# X, active# fst X -> fst# active X)
        (active# fst X -> active# X, active# head X -> active# X)
        (active# fst X -> active# X, active# head X -> head# active X)
        (active# fst X -> active# X, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# fst X -> active# X, active# natsFrom N -> natsFrom# s N)
        (active# fst X -> active# X, active# natsFrom N -> s# N)
        (active# fst X -> active# X, active# natsFrom X -> active# X)
        (active# fst X -> active# X, active# natsFrom X -> natsFrom# active X)
        (active# fst X -> active# X, active# s X -> active# X)
        (active# fst X -> active# X, active# s X -> s# active X)
        (active# fst X -> active# X, active# sel(N, XS) -> afterNth#(N, XS))
        (active# fst X -> active# X, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# fst X -> active# X, active# sel(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# sel(X1, X2) -> active# X2)
        (active# fst X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# fst X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# fst X -> active# X, active# tail X -> active# X)
        (active# fst X -> active# X, active# tail X -> tail# active X)
        (active# fst X -> active# X, active# take(N, XS) -> splitAt#(N, XS))
        (active# fst X -> active# X, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# fst X -> active# X, active# take(X1, X2) -> active# X1)
        (active# fst X -> active# X, active# take(X1, X2) -> active# X2)
        (active# fst X -> active# X, active# take(X1, X2) -> take#(X1, active X2))
        (active# fst X -> active# X, active# take(X1, X2) -> take#(active X1, X2))
        (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(X1, mark X2) -> take#(X1, X2))
        (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(mark X1, X2) -> take#(X1, X2))
        (proper# take(X1, X2) -> take#(proper X1, proper X2), take#(ok X1, ok X2) -> take#(X1, X2))
        (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
        (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(mark X1, X2) -> cons#(X1, X2))
        (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
        (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
        (proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
        (active# take(X1, X2) -> take#(X1, active X2), take#(X1, mark X2) -> take#(X1, X2))
        (active# take(X1, X2) -> take#(X1, active X2), take#(mark X1, X2) -> take#(X1, X2))
        (active# take(X1, X2) -> take#(X1, active X2), take#(ok X1, ok X2) -> take#(X1, X2))
        (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
        (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
        (active# afterNth(X1, X2) -> afterNth#(X1, active X2), afterNth#(ok X1, ok X2) -> afterNth#(X1, X2))
        (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
        (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
        (active# splitAt(X1, X2) -> splitAt#(X1, active X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
        (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# take(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# take(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# take(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# take(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# take(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# take(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# take(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# take(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# take(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# take(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# take(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# and(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# cons(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# snd X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# fst X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> head# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# head X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> s# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# s X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# tail X -> proper# X)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# U11(X1, X2, X3, X4) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# U12(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# splitAt(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# U12(X1, X2) -> proper# X1, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# pair(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# snd X -> snd# proper X)
        (proper# U12(X1, X2) -> proper# X1, proper# snd X -> proper# X)
        (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# afterNth(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# fst X -> fst# proper X)
        (proper# U12(X1, X2) -> proper# X1, proper# fst X -> proper# X)
        (proper# U12(X1, X2) -> proper# X1, proper# head X -> head# proper X)
        (proper# U12(X1, X2) -> proper# X1, proper# head X -> proper# X)
        (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> natsFrom# proper X)
        (proper# U12(X1, X2) -> proper# X1, proper# natsFrom X -> proper# X)
        (proper# U12(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# U12(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
        (proper# U12(X1, X2) -> proper# X1, proper# tail X -> tail# proper X)
        (proper# U12(X1, X2) -> proper# X1, proper# tail X -> proper# X)
        (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X1)
        (proper# U12(X1, X2) -> proper# X1, proper# take(X1, X2) -> proper# X2)
        (active# take(N, XS) -> fst# splitAt(N, XS), fst# mark X -> fst# X)
        (active# take(N, XS) -> fst# splitAt(N, XS), fst# ok X -> fst# X)
        (active# sel(N, XS) -> head# afterNth(N, XS), head# mark X -> head# X)
        (active# sel(N, XS) -> head# afterNth(N, XS), head# ok X -> head# X)
        (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# afterNth(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# afterNth(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# afterNth(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# afterNth(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# afterNth(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# afterNth(X1, X2) -> active# X1, active# head X -> active# X)
        (active# afterNth(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# afterNth(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# afterNth(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# afterNth(X1, X2) -> active# X1, active# s X -> active# X)
        (active# afterNth(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# afterNth(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# cons(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# cons(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# cons(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# cons(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# cons(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# cons(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# cons(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# cons(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# cons(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# cons(X1, X2) -> active# X1, active# head X -> active# X)
        (active# cons(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# cons(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# cons(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# cons(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# cons(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# cons(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# cons(X1, X2) -> active# X1, active# s X -> active# X)
        (active# cons(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# cons(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# cons(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# cons(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# cons(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# cons(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> active# X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# snd X -> snd# active X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> active# X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# fst X -> fst# active X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> active# X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# head X -> head# active X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom N -> s# N)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> active# X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> active# X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# s X -> s# active X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> active# X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# tail X -> tail# active X)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# U11(X1, X2, X3, X4) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# U12(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# U12(X1, X2) -> active# X1, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# splitAt(X1, X2) -> active# X2)
        (active# U12(X1, X2) -> active# X1, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# U12(X1, X2) -> active# X1, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# U12(X1, X2) -> active# X1, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> active# X2)
        (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# U12(X1, X2) -> active# X1, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# snd X -> active# X)
        (active# U12(X1, X2) -> active# X1, active# snd X -> snd# active X)
        (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# U12(X1, X2) -> active# X1, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> active# X2)
        (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# U12(X1, X2) -> active# X1, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# fst X -> active# X)
        (active# U12(X1, X2) -> active# X1, active# fst X -> fst# active X)
        (active# U12(X1, X2) -> active# X1, active# head X -> active# X)
        (active# U12(X1, X2) -> active# X1, active# head X -> head# active X)
        (active# U12(X1, X2) -> active# X1, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# U12(X1, X2) -> active# X1, active# natsFrom N -> natsFrom# s N)
        (active# U12(X1, X2) -> active# X1, active# natsFrom N -> s# N)
        (active# U12(X1, X2) -> active# X1, active# natsFrom X -> active# X)
        (active# U12(X1, X2) -> active# X1, active# natsFrom X -> natsFrom# active X)
        (active# U12(X1, X2) -> active# X1, active# s X -> active# X)
        (active# U12(X1, X2) -> active# X1, active# s X -> s# active X)
        (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> afterNth#(N, XS))
        (active# U12(X1, X2) -> active# X1, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
        (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# U12(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# U12(X1, X2) -> active# X1, active# tail X -> active# X)
        (active# U12(X1, X2) -> active# X1, active# tail X -> tail# active X)
        (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> splitAt#(N, XS))
        (active# U12(X1, X2) -> active# X1, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X1)
        (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> active# X2)
        (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(X1, active X2))
        (active# U12(X1, X2) -> active# X1, active# take(X1, X2) -> take#(active X1, X2))
        (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
        (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
        (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
        (active# U11(tt(), N, X, XS) -> splitAt#(N, XS), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
        (take#(mark X1, X2) -> take#(X1, X2), take#(X1, mark 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#(ok X1, ok X2) -> take#(X1, X2))
        (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
        (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
        (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(ok X1, ok 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#(mark X1, X2) -> sel#(X1, X2))
        (sel#(X1, mark X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
        (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
        (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark 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#(ok X1, ok X2) -> afterNth#(X1, X2))
        (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
        (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
        (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
        (pair#(ok X1, ok X2) -> pair#(X1, X2), pair#(ok X1, ok 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#(mark X1, X2) -> pair#(X1, X2))
        (pair#(X1, mark X2) -> pair#(X1, X2), pair#(ok X1, ok X2) -> pair#(X1, X2))
        (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark 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#(ok X1, ok X2) -> splitAt#(X1, X2))
        (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
        (U12#(ok X1, ok X2) -> U12#(X1, X2), U12#(ok X1, ok X2) -> U12#(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#(ok X1, ok X2) -> cons#(X1, X2))
        (active# take(X1, X2) -> take#(active X1, X2), take#(X1, mark X2) -> take#(X1, X2))
        (active# take(X1, X2) -> take#(active X1, X2), take#(mark X1, X2) -> take#(X1, X2))
        (active# take(X1, X2) -> take#(active X1, X2), take#(ok X1, ok X2) -> take#(X1, X2))
        (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
        (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (active# cons(X1, X2) -> cons#(active X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
        (active# cons(X1, X2) -> cons#(active X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
        (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
        (active# splitAt(X1, X2) -> splitAt#(active X1, X2), splitAt#(ok X1, ok X2) -> splitAt#(X1, X2))
        (active# natsFrom N -> s# N, s# mark X -> s# X)
        (active# natsFrom N -> s# N, s# ok X -> s# X)
        (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# sel(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# sel(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# sel(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# sel(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# sel(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# sel(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# sel(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# sel(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# sel(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# sel(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# sel(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# afterNth(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# afterNth(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# pair(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# pair(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# pair(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# pair(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# pair(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# pair(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# pair(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# pair(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# pair(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# pair(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# pair(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> U12#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# U12(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> splitAt#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# splitAt(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> U11#(proper X1, proper X2, proper X3, proper X4))
        (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X3)
        (proper# splitAt(X1, X2) -> proper# X2, proper# U11(X1, X2, X3, X4) -> proper# X4)
        (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> pair#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# pair(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> snd# proper X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# snd X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> afterNth#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# afterNth(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> fst# proper X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# fst X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> head# proper X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# head X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> natsFrom# proper X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# natsFrom X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
        (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> tail# proper X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# tail X -> proper# X)
        (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> take#(proper X1, proper X2))
        (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X1)
        (proper# splitAt(X1, X2) -> proper# X2, proper# take(X1, X2) -> proper# X2)
        (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# take(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# take(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# take(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# take(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# snd X -> active# X)
        (active# take(X1, X2) -> active# X2, active# snd X -> snd# active X)
        (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# take(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# take(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# fst X -> active# X)
        (active# take(X1, X2) -> active# X2, active# fst X -> fst# active X)
        (active# take(X1, X2) -> active# X2, active# head X -> active# X)
        (active# take(X1, X2) -> active# X2, active# head X -> head# active X)
        (active# take(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# take(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
        (active# take(X1, X2) -> active# X2, active# natsFrom N -> s# N)
        (active# take(X1, X2) -> active# X2, active# natsFrom X -> active# X)
        (active# take(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
        (active# take(X1, X2) -> active# X2, active# s X -> active# X)
        (active# take(X1, X2) -> active# X2, active# s X -> s# active X)
        (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
        (active# take(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# take(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# take(X1, X2) -> active# X2, active# tail X -> active# X)
        (active# take(X1, X2) -> active# X2, active# tail X -> tail# active X)
        (active# take(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
        (active# take(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
        (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
        (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
        (active# take(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# afterNth(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# afterNth(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# afterNth(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# snd X -> active# X)
        (active# afterNth(X1, X2) -> active# X2, active# snd X -> snd# active X)
        (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# fst X -> active# X)
        (active# afterNth(X1, X2) -> active# X2, active# fst X -> fst# active X)
        (active# afterNth(X1, X2) -> active# X2, active# head X -> active# X)
        (active# afterNth(X1, X2) -> active# X2, active# head X -> head# active X)
        (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
        (active# afterNth(X1, X2) -> active# X2, active# natsFrom N -> s# N)
        (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> active# X)
        (active# afterNth(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
        (active# afterNth(X1, X2) -> active# X2, active# s X -> active# X)
        (active# afterNth(X1, X2) -> active# X2, active# s X -> s# active X)
        (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# afterNth(X1, X2) -> active# X2, active# tail X -> active# X)
        (active# afterNth(X1, X2) -> active# X2, active# tail X -> tail# active X)
        (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
        (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
        (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
        (active# afterNth(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> U12#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# U12(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
        (active# splitAt(X1, X2) -> active# X2, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
        (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> splitAt#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# splitAt(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X2, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
        (active# splitAt(X1, X2) -> active# X2, active# splitAt(0(), XS) -> pair#(nil(), XS))
        (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# U11(X1, X2, X3, X4) -> U11#(active X1, X2, X3, X4))
        (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
        (active# splitAt(X1, X2) -> active# X2, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X2, active# pair(X1, X2) -> pair#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# snd X -> active# X)
        (active# splitAt(X1, X2) -> active# X2, active# snd X -> snd# active X)
        (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> splitAt#(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# afterNth(N, XS) -> snd# splitAt(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X2, active# afterNth(X1, X2) -> afterNth#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# fst X -> active# X)
        (active# splitAt(X1, X2) -> active# X2, active# fst X -> fst# active X)
        (active# splitAt(X1, X2) -> active# X2, active# head X -> active# X)
        (active# splitAt(X1, X2) -> active# X2, active# head X -> head# active X)
        (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> cons#(N, natsFrom s N))
        (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> natsFrom# s N)
        (active# splitAt(X1, X2) -> active# X2, active# natsFrom N -> s# N)
        (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> active# X)
        (active# splitAt(X1, X2) -> active# X2, active# natsFrom X -> natsFrom# active X)
        (active# splitAt(X1, X2) -> active# X2, active# s X -> active# X)
        (active# splitAt(X1, X2) -> active# X2, active# s X -> s# active X)
        (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> afterNth#(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# sel(N, XS) -> head# afterNth(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
        (active# splitAt(X1, X2) -> active# X2, active# tail X -> active# X)
        (active# splitAt(X1, X2) -> active# X2, active# tail X -> tail# active X)
        (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> splitAt#(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# take(N, XS) -> fst# splitAt(N, XS))
        (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X1)
        (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> active# X2)
        (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(X1, active X2))
        (active# splitAt(X1, X2) -> active# X2, active# take(X1, X2) -> take#(active X1, X2))
       }
       STATUS:
        arrows: 0.864362
        SCCS (18):
         Scc:
          {top# mark X -> top# proper X,
             top# ok X -> top# active X}
         Scc:
          {        proper# U12(X1, X2) -> proper# X1,
                   proper# U12(X1, X2) -> proper# X2,
               proper# splitAt(X1, X2) -> proper# X1,
               proper# splitAt(X1, X2) -> proper# X2,
           proper# U11(X1, X2, X3, X4) -> proper# X1,
           proper# U11(X1, X2, X3, X4) -> proper# X2,
           proper# U11(X1, X2, X3, X4) -> proper# X3,
           proper# U11(X1, X2, X3, X4) -> proper# X4,
                  proper# pair(X1, X2) -> proper# X1,
                  proper# pair(X1, X2) -> proper# X2,
                  proper# cons(X1, X2) -> proper# X1,
                  proper# cons(X1, X2) -> proper# X2,
                         proper# snd X -> proper# X,
              proper# afterNth(X1, X2) -> proper# X1,
              proper# afterNth(X1, X2) -> proper# X2,
                   proper# and(X1, X2) -> proper# X1,
                   proper# and(X1, X2) -> proper# X2,
                         proper# fst X -> proper# X,
                        proper# head X -> proper# X,
                    proper# natsFrom X -> proper# X,
                           proper# s X -> proper# X,
                   proper# sel(X1, X2) -> proper# X1,
                   proper# sel(X1, X2) -> proper# X2,
                        proper# tail X -> proper# X,
                  proper# take(X1, X2) -> proper# X1,
                  proper# take(X1, X2) -> proper# X2}
         Scc:
          {        active# U12(X1, X2) -> active# X1,
               active# splitAt(X1, X2) -> active# X1,
               active# splitAt(X1, X2) -> active# X2,
           active# U11(X1, X2, X3, X4) -> active# X1,
                  active# pair(X1, X2) -> active# X1,
                  active# pair(X1, X2) -> active# X2,
                  active# cons(X1, X2) -> active# X1,
                         active# snd X -> active# X,
              active# afterNth(X1, X2) -> active# X1,
              active# afterNth(X1, X2) -> active# X2,
                   active# and(X1, X2) -> active# X1,
                         active# fst X -> active# X,
                        active# head X -> active# X,
                    active# natsFrom X -> active# X,
                           active# s X -> active# X,
                   active# sel(X1, X2) -> active# X1,
                   active# sel(X1, X2) -> active# X2,
                        active# tail X -> active# X,
                  active# take(X1, X2) -> active# X1,
                  active# take(X1, X2) -> active# X2}
         Scc:
          { take#(X1, mark X2) -> take#(X1, X2),
            take#(mark X1, X2) -> take#(X1, X2),
           take#(ok X1, ok X2) -> take#(X1, X2)}
         Scc:
          {tail# mark X -> tail# X,
             tail# ok X -> tail# X}
         Scc:
          { sel#(X1, mark X2) -> sel#(X1, X2),
            sel#(mark X1, X2) -> sel#(X1, X2),
           sel#(ok X1, ok X2) -> sel#(X1, X2)}
         Scc:
          {s# mark X -> s# X,
             s# ok X -> s# X}
         Scc:
          {natsFrom# mark X -> natsFrom# X,
             natsFrom# ok X -> natsFrom# X}
         Scc:
          {head# mark X -> head# X,
             head# ok X -> head# X}
         Scc:
          {fst# mark X -> fst# X,
             fst# ok X -> fst# X}
         Scc:
          { and#(mark X1, X2) -> and#(X1, X2),
           and#(ok X1, ok X2) -> and#(X1, X2)}
         Scc:
          { afterNth#(X1, mark X2) -> afterNth#(X1, X2),
            afterNth#(mark X1, X2) -> afterNth#(X1, X2),
           afterNth#(ok X1, ok X2) -> afterNth#(X1, X2)}
         Scc:
          {snd# mark X -> snd# X,
             snd# ok X -> snd# X}
         Scc:
          {       U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
           U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4)}
         Scc:
          { splitAt#(X1, mark X2) -> splitAt#(X1, X2),
            splitAt#(mark X1, X2) -> splitAt#(X1, X2),
           splitAt#(ok X1, ok X2) -> splitAt#(X1, X2)}
         Scc:
          { cons#(mark X1, X2) -> cons#(X1, X2),
           cons#(ok X1, ok X2) -> cons#(X1, X2)}
         Scc:
          { pair#(X1, mark X2) -> pair#(X1, X2),
            pair#(mark X1, X2) -> pair#(X1, X2),
           pair#(ok X1, ok X2) -> pair#(X1, X2)}
         Scc:
          { U12#(mark X1, X2) -> U12#(X1, X2),
           U12#(ok X1, ok X2) -> U12#(X1, X2)}
         
         SCC (2):
          Strict:
           {top# mark X -> top# proper X,
              top# ok X -> top# active X}
          Weak:
          {                U12(mark X1, X2) -> mark U12(X1, X2),
                          U12(ok X1, ok X2) -> ok U12(X1, X2),
                       splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                       splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                      splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                         active U12(X1, X2) -> U12(active X1, X2),
                active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                     active splitAt(X1, X2) -> splitAt(X1, active X2),
                     active splitAt(X1, X2) -> splitAt(active X1, X2),
           active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                    active splitAt(0(), XS) -> mark pair(nil(), XS),
                 active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                 active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                        active pair(X1, X2) -> pair(X1, active X2),
                        active pair(X1, X2) -> pair(active X1, X2),
                        active cons(X1, X2) -> cons(active X1, X2),
                               active snd X -> snd active X,
                      active snd pair(X, Y) -> mark Y,
                     active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active afterNth(X1, X2) -> afterNth(X1, active X2),
                    active afterNth(X1, X2) -> afterNth(active X1, X2),
                         active and(X1, X2) -> and(active X1, X2),
                        active and(tt(), X) -> mark X,
                               active fst X -> fst active X,
                      active fst pair(X, Y) -> mark X,
                              active head X -> head active X,
                    active head cons(N, XS) -> mark N,
                          active natsFrom N -> mark cons(N, natsFrom s N),
                          active natsFrom X -> natsFrom active X,
                                 active s X -> s active X,
                          active sel(N, XS) -> mark head afterNth(N, XS),
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
                              active tail X -> tail active X,
                    active tail cons(N, XS) -> mark XS,
                         active take(N, XS) -> mark fst splitAt(N, XS),
                        active take(X1, X2) -> take(X1, active X2),
                        active take(X1, X2) -> take(active X1, X2),
                   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
            U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                          pair(X1, mark X2) -> mark pair(X1, X2),
                          pair(mark X1, X2) -> mark pair(X1, X2),
                         pair(ok X1, ok X2) -> ok pair(X1, X2),
                          cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                 snd mark X -> mark snd X,
                                   snd ok X -> ok snd X,
                      afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                      afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                           and(mark X1, X2) -> mark and(X1, X2),
                          and(ok X1, ok X2) -> ok and(X1, X2),
                                 fst mark X -> mark fst X,
                                   fst ok X -> ok fst X,
                                head mark X -> mark head X,
                                  head ok X -> ok head X,
                            natsFrom mark X -> mark natsFrom X,
                              natsFrom ok X -> ok natsFrom X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                                tail mark X -> mark tail X,
                                  tail ok X -> ok tail X,
                          take(X1, mark X2) -> mark take(X1, X2),
                          take(mark X1, X2) -> mark take(X1, X2),
                         take(ok X1, ok X2) -> ok take(X1, X2),
                         proper U12(X1, X2) -> U12(proper X1, proper X2),
                     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                 proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                proper tt() -> ok tt(),
                        proper pair(X1, X2) -> pair(proper X1, proper X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                               proper snd X -> snd proper X,
                    proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                         proper and(X1, X2) -> and(proper X1, proper X2),
                               proper fst X -> fst proper X,
                              proper head X -> head proper X,
                          proper natsFrom X -> natsFrom proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper nil() -> ok nil(),
                                 proper 0() -> ok 0(),
                              proper tail X -> tail proper X,
                        proper take(X1, X2) -> take(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
          Fail
         
         
         SCC (26):
          Strict:
           {        proper# U12(X1, X2) -> proper# X1,
                    proper# U12(X1, X2) -> proper# X2,
                proper# splitAt(X1, X2) -> proper# X1,
                proper# splitAt(X1, X2) -> proper# X2,
            proper# U11(X1, X2, X3, X4) -> proper# X1,
            proper# U11(X1, X2, X3, X4) -> proper# X2,
            proper# U11(X1, X2, X3, X4) -> proper# X3,
            proper# U11(X1, X2, X3, X4) -> proper# X4,
                   proper# pair(X1, X2) -> proper# X1,
                   proper# pair(X1, X2) -> proper# X2,
                   proper# cons(X1, X2) -> proper# X1,
                   proper# cons(X1, X2) -> proper# X2,
                          proper# snd X -> proper# X,
               proper# afterNth(X1, X2) -> proper# X1,
               proper# afterNth(X1, X2) -> proper# X2,
                    proper# and(X1, X2) -> proper# X1,
                    proper# and(X1, X2) -> proper# X2,
                          proper# fst X -> proper# X,
                         proper# head X -> proper# X,
                     proper# natsFrom X -> proper# X,
                            proper# s X -> proper# X,
                    proper# sel(X1, X2) -> proper# X1,
                    proper# sel(X1, X2) -> proper# X2,
                         proper# tail X -> proper# X,
                   proper# take(X1, X2) -> proper# X1,
                   proper# take(X1, X2) -> proper# X2}
          Weak:
          {                U12(mark X1, X2) -> mark U12(X1, X2),
                          U12(ok X1, ok X2) -> ok U12(X1, X2),
                       splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                       splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                      splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                         active U12(X1, X2) -> U12(active X1, X2),
                active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                     active splitAt(X1, X2) -> splitAt(X1, active X2),
                     active splitAt(X1, X2) -> splitAt(active X1, X2),
           active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                    active splitAt(0(), XS) -> mark pair(nil(), XS),
                 active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                 active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                        active pair(X1, X2) -> pair(X1, active X2),
                        active pair(X1, X2) -> pair(active X1, X2),
                        active cons(X1, X2) -> cons(active X1, X2),
                               active snd X -> snd active X,
                      active snd pair(X, Y) -> mark Y,
                     active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active afterNth(X1, X2) -> afterNth(X1, active X2),
                    active afterNth(X1, X2) -> afterNth(active X1, X2),
                         active and(X1, X2) -> and(active X1, X2),
                        active and(tt(), X) -> mark X,
                               active fst X -> fst active X,
                      active fst pair(X, Y) -> mark X,
                              active head X -> head active X,
                    active head cons(N, XS) -> mark N,
                          active natsFrom N -> mark cons(N, natsFrom s N),
                          active natsFrom X -> natsFrom active X,
                                 active s X -> s active X,
                          active sel(N, XS) -> mark head afterNth(N, XS),
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
                              active tail X -> tail active X,
                    active tail cons(N, XS) -> mark XS,
                         active take(N, XS) -> mark fst splitAt(N, XS),
                        active take(X1, X2) -> take(X1, active X2),
                        active take(X1, X2) -> take(active X1, X2),
                   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
            U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                          pair(X1, mark X2) -> mark pair(X1, X2),
                          pair(mark X1, X2) -> mark pair(X1, X2),
                         pair(ok X1, ok X2) -> ok pair(X1, X2),
                          cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                 snd mark X -> mark snd X,
                                   snd ok X -> ok snd X,
                      afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                      afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                           and(mark X1, X2) -> mark and(X1, X2),
                          and(ok X1, ok X2) -> ok and(X1, X2),
                                 fst mark X -> mark fst X,
                                   fst ok X -> ok fst X,
                                head mark X -> mark head X,
                                  head ok X -> ok head X,
                            natsFrom mark X -> mark natsFrom X,
                              natsFrom ok X -> ok natsFrom X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                                tail mark X -> mark tail X,
                                  tail ok X -> ok tail X,
                          take(X1, mark X2) -> mark take(X1, X2),
                          take(mark X1, X2) -> mark take(X1, X2),
                         take(ok X1, ok X2) -> ok take(X1, X2),
                         proper U12(X1, X2) -> U12(proper X1, proper X2),
                     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                 proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                proper tt() -> ok tt(),
                        proper pair(X1, X2) -> pair(proper X1, proper X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                               proper snd X -> snd proper X,
                    proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                         proper and(X1, X2) -> and(proper X1, proper X2),
                               proper fst X -> fst proper X,
                              proper head X -> head proper X,
                          proper natsFrom X -> natsFrom proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper nil() -> ok nil(),
                                 proper 0() -> ok 0(),
                              proper tail X -> tail proper X,
                        proper take(X1, X2) -> take(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
          POLY:
           Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
           Interpretation:
            [U11](x0, x1, x2, x3) = x0 + x1 + x2 + x3,
            
            [U12](x0, x1) = x0 + x1,
            
            [splitAt](x0, x1) = x0 + x1,
            
            [pair](x0, x1) = x0 + x1,
            
            [cons](x0, x1) = x0 + x1,
            
            [afterNth](x0, x1) = x0 + x1,
            
            [and](x0, x1) = x0 + x1,
            
            [sel](x0, x1) = x0 + x1,
            
            [take](x0, x1) = x0 + x1 + 1,
            
            [mark](x0) = x0,
            
            [active](x0) = 0,
            
            [snd](x0) = x0,
            
            [fst](x0) = x0,
            
            [head](x0) = x0,
            
            [natsFrom](x0) = x0,
            
            [s](x0) = x0,
            
            [tail](x0) = x0,
            
            [proper](x0) = 0,
            
            [ok](x0) = x0 + 1,
            
            [top](x0) = 0,
            
            [tt] = 0,
            
            [nil] = 0,
            
            [0] = 0,
            
            [proper#](x0) = x0
           Strict:
            proper# take(X1, X2) -> proper# X2
            1 + 1X1 + 1X2 >= 0 + 1X2
            proper# take(X1, X2) -> proper# X1
            1 + 1X1 + 1X2 >= 0 + 1X1
            proper# tail X -> proper# X
            0 + 1X >= 0 + 1X
            proper# sel(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# sel(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
            proper# s X -> proper# X
            0 + 1X >= 0 + 1X
            proper# natsFrom X -> proper# X
            0 + 1X >= 0 + 1X
            proper# head X -> proper# X
            0 + 1X >= 0 + 1X
            proper# fst X -> proper# X
            0 + 1X >= 0 + 1X
            proper# and(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# and(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
            proper# afterNth(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# afterNth(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
            proper# snd X -> proper# X
            0 + 1X >= 0 + 1X
            proper# cons(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# cons(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
            proper# pair(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# pair(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
            proper# U11(X1, X2, X3, X4) -> proper# X4
            0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X4
            proper# U11(X1, X2, X3, X4) -> proper# X3
            0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X3
            proper# U11(X1, X2, X3, X4) -> proper# X2
            0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X2
            proper# U11(X1, X2, X3, X4) -> proper# X1
            0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X1
            proper# splitAt(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# splitAt(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
            proper# U12(X1, X2) -> proper# X2
            0 + 1X1 + 1X2 >= 0 + 1X2
            proper# U12(X1, X2) -> proper# X1
            0 + 1X1 + 1X2 >= 0 + 1X1
           Weak:
            top ok X -> top active X
            0 + 0X >= 0 + 0X
            top mark X -> top proper X
            0 + 0X >= 0 + 0X
            proper take(X1, X2) -> take(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
            proper tail X -> tail proper X
            0 + 0X >= 0 + 0X
            proper 0() -> ok 0()
            0 >= 1
            proper nil() -> ok nil()
            0 >= 1
            proper sel(X1, X2) -> sel(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper s X -> s proper X
            0 + 0X >= 0 + 0X
            proper natsFrom X -> natsFrom proper X
            0 + 0X >= 0 + 0X
            proper head X -> head proper X
            0 + 0X >= 0 + 0X
            proper fst X -> fst proper X
            0 + 0X >= 0 + 0X
            proper and(X1, X2) -> and(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper snd X -> snd proper X
            0 + 0X >= 0 + 0X
            proper cons(X1, X2) -> cons(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper pair(X1, X2) -> pair(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper tt() -> ok tt()
            0 >= 1
            proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
            0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper U12(X1, X2) -> U12(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            take(ok X1, ok X2) -> ok take(X1, X2)
            3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
            take(mark X1, X2) -> mark take(X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            take(X1, mark X2) -> mark take(X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            tail ok X -> ok tail X
            1 + 1X >= 1 + 1X
            tail mark X -> mark tail X
            0 + 1X >= 0 + 1X
            sel(ok X1, ok X2) -> ok sel(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            sel(mark X1, X2) -> mark sel(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            sel(X1, mark X2) -> mark sel(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            s ok X -> ok s X
            1 + 1X >= 1 + 1X
            s mark X -> mark s X
            0 + 1X >= 0 + 1X
            natsFrom ok X -> ok natsFrom X
            1 + 1X >= 1 + 1X
            natsFrom mark X -> mark natsFrom X
            0 + 1X >= 0 + 1X
            head ok X -> ok head X
            1 + 1X >= 1 + 1X
            head mark X -> mark head X
            0 + 1X >= 0 + 1X
            fst ok X -> ok fst X
            1 + 1X >= 1 + 1X
            fst mark X -> mark fst X
            0 + 1X >= 0 + 1X
            and(ok X1, ok X2) -> ok and(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            and(mark X1, X2) -> mark and(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            afterNth(mark X1, X2) -> mark afterNth(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            afterNth(X1, mark X2) -> mark afterNth(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            snd ok X -> ok snd X
            1 + 1X >= 1 + 1X
            snd mark X -> mark snd X
            0 + 1X >= 0 + 1X
            cons(ok X1, ok X2) -> ok cons(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            cons(mark X1, X2) -> mark cons(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            pair(ok X1, ok X2) -> ok pair(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            pair(mark X1, X2) -> mark pair(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            pair(X1, mark X2) -> mark pair(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
            4 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1 + 1X2 + 1X3 + 1X4
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
            0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X1 + 1X2 + 1X3 + 1X4
            active take(X1, X2) -> take(active X1, X2)
            0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
            active take(X1, X2) -> take(X1, active X2)
            0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
            active take(N, XS) -> mark fst splitAt(N, XS)
            0 + 0N + 0XS >= 0 + 1N + 1XS
            active tail cons(N, XS) -> mark XS
            0 + 0N + 0XS >= 0 + 1XS
            active tail X -> tail active X
            0 + 0X >= 0 + 0X
            active sel(X1, X2) -> sel(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            active sel(X1, X2) -> sel(X1, active X2)
            0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
            active sel(N, XS) -> mark head afterNth(N, XS)
            0 + 0N + 0XS >= 0 + 1N + 1XS
            active s X -> s active X
            0 + 0X >= 0 + 0X
            active natsFrom X -> natsFrom active X
            0 + 0X >= 0 + 0X
            active natsFrom N -> mark cons(N, natsFrom s N)
            0 + 0N >= 0 + 2N
            active head cons(N, XS) -> mark N
            0 + 0N + 0XS >= 0 + 1N
            active head X -> head active X
            0 + 0X >= 0 + 0X
            active fst pair(X, Y) -> mark X
            0 + 0X + 0Y >= 0 + 1X
            active fst X -> fst active X
            0 + 0X >= 0 + 0X
            active and(tt(), X) -> mark X
            0 + 0X >= 0 + 1X
            active and(X1, X2) -> and(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            active afterNth(X1, X2) -> afterNth(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            active afterNth(X1, X2) -> afterNth(X1, active X2)
            0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
            active afterNth(N, XS) -> mark snd splitAt(N, XS)
            0 + 0N + 0XS >= 0 + 1N + 1XS
            active snd pair(X, Y) -> mark Y
            0 + 0X + 0Y >= 0 + 1Y
            active snd X -> snd active X
            0 + 0X >= 0 + 0X
            active cons(X1, X2) -> cons(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            active pair(X1, X2) -> pair(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            active pair(X1, X2) -> pair(X1, active X2)
            0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
            active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
            0 + 0N + 0XS + 0X >= 0 + 1N + 1XS + 1X
            active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
            0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 1X2 + 1X3 + 1X4
            active splitAt(0(), XS) -> mark pair(nil(), XS)
            0 + 0XS >= 0 + 1XS
            active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
            0 + 0N + 0XS + 0X >= 0 + 1N + 1XS + 1X
            active splitAt(X1, X2) -> splitAt(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            active splitAt(X1, X2) -> splitAt(X1, active X2)
            0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
            0 + 0X + 0YS + 0ZS >= 0 + 1X + 1YS + 1ZS
            active U12(X1, X2) -> U12(active X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
            splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            splitAt(mark X1, X2) -> mark splitAt(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            splitAt(X1, mark X2) -> mark splitAt(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            U12(ok X1, ok X2) -> ok U12(X1, X2)
            2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            U12(mark X1, X2) -> mark U12(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
          SCCS (1):
           Scc:
            {        proper# U12(X1, X2) -> proper# X1,
                     proper# U12(X1, X2) -> proper# X2,
                 proper# splitAt(X1, X2) -> proper# X1,
                 proper# splitAt(X1, X2) -> proper# X2,
             proper# U11(X1, X2, X3, X4) -> proper# X1,
             proper# U11(X1, X2, X3, X4) -> proper# X2,
             proper# U11(X1, X2, X3, X4) -> proper# X3,
             proper# U11(X1, X2, X3, X4) -> proper# X4,
                    proper# pair(X1, X2) -> proper# X1,
                    proper# pair(X1, X2) -> proper# X2,
                    proper# cons(X1, X2) -> proper# X1,
                    proper# cons(X1, X2) -> proper# X2,
                           proper# snd X -> proper# X,
                proper# afterNth(X1, X2) -> proper# X1,
                proper# afterNth(X1, X2) -> proper# X2,
                     proper# and(X1, X2) -> proper# X1,
                     proper# and(X1, X2) -> proper# X2,
                           proper# fst X -> proper# X,
                          proper# head X -> proper# X,
                      proper# natsFrom X -> proper# X,
                             proper# s X -> proper# X,
                     proper# sel(X1, X2) -> proper# X1,
                     proper# sel(X1, X2) -> proper# X2,
                          proper# tail X -> proper# X}
           
           SCC (24):
            Strict:
             {        proper# U12(X1, X2) -> proper# X1,
                      proper# U12(X1, X2) -> proper# X2,
                  proper# splitAt(X1, X2) -> proper# X1,
                  proper# splitAt(X1, X2) -> proper# X2,
              proper# U11(X1, X2, X3, X4) -> proper# X1,
              proper# U11(X1, X2, X3, X4) -> proper# X2,
              proper# U11(X1, X2, X3, X4) -> proper# X3,
              proper# U11(X1, X2, X3, X4) -> proper# X4,
                     proper# pair(X1, X2) -> proper# X1,
                     proper# pair(X1, X2) -> proper# X2,
                     proper# cons(X1, X2) -> proper# X1,
                     proper# cons(X1, X2) -> proper# X2,
                            proper# snd X -> proper# X,
                 proper# afterNth(X1, X2) -> proper# X1,
                 proper# afterNth(X1, X2) -> proper# X2,
                      proper# and(X1, X2) -> proper# X1,
                      proper# and(X1, X2) -> proper# X2,
                            proper# fst X -> proper# X,
                           proper# head X -> proper# X,
                       proper# natsFrom X -> proper# X,
                              proper# s X -> proper# X,
                      proper# sel(X1, X2) -> proper# X1,
                      proper# sel(X1, X2) -> proper# X2,
                           proper# tail X -> proper# X}
            Weak:
            {                U12(mark X1, X2) -> mark U12(X1, X2),
                            U12(ok X1, ok X2) -> ok U12(X1, X2),
                         splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                         splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                        splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                           active U12(X1, X2) -> U12(active X1, X2),
                  active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                       active splitAt(X1, X2) -> splitAt(X1, active X2),
                       active splitAt(X1, X2) -> splitAt(active X1, X2),
             active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                      active splitAt(0(), XS) -> mark pair(nil(), XS),
                   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                          active pair(X1, X2) -> pair(X1, active X2),
                          active pair(X1, X2) -> pair(active X1, X2),
                          active cons(X1, X2) -> cons(active X1, X2),
                                 active snd X -> snd active X,
                        active snd pair(X, Y) -> mark Y,
                       active afterNth(N, XS) -> mark snd splitAt(N, XS),
                      active afterNth(X1, X2) -> afterNth(X1, active X2),
                      active afterNth(X1, X2) -> afterNth(active X1, X2),
                           active and(X1, X2) -> and(active X1, X2),
                          active and(tt(), X) -> mark X,
                                 active fst X -> fst active X,
                        active fst pair(X, Y) -> mark X,
                                active head X -> head active X,
                      active head cons(N, XS) -> mark N,
                            active natsFrom N -> mark cons(N, natsFrom s N),
                            active natsFrom X -> natsFrom active X,
                                   active s X -> s active X,
                            active sel(N, XS) -> mark head afterNth(N, XS),
                           active sel(X1, X2) -> sel(X1, active X2),
                           active sel(X1, X2) -> sel(active X1, X2),
                                active tail X -> tail active X,
                      active tail cons(N, XS) -> mark XS,
                           active take(N, XS) -> mark fst splitAt(N, XS),
                          active take(X1, X2) -> take(X1, active X2),
                          active take(X1, X2) -> take(active X1, X2),
                     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
              U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                            pair(X1, mark X2) -> mark pair(X1, X2),
                            pair(mark X1, X2) -> mark pair(X1, X2),
                           pair(ok X1, ok X2) -> ok pair(X1, X2),
                            cons(mark X1, X2) -> mark cons(X1, X2),
                           cons(ok X1, ok X2) -> ok cons(X1, X2),
                                   snd mark X -> mark snd X,
                                     snd ok X -> ok snd X,
                        afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                        afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                       afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                             and(mark X1, X2) -> mark and(X1, X2),
                            and(ok X1, ok X2) -> ok and(X1, X2),
                                   fst mark X -> mark fst X,
                                     fst ok X -> ok fst X,
                                  head mark X -> mark head X,
                                    head ok X -> ok head X,
                              natsFrom mark X -> mark natsFrom X,
                                natsFrom ok X -> ok natsFrom X,
                                     s mark X -> mark s X,
                                       s ok X -> ok s X,
                             sel(X1, mark X2) -> mark sel(X1, X2),
                             sel(mark X1, X2) -> mark sel(X1, X2),
                            sel(ok X1, ok X2) -> ok sel(X1, X2),
                                  tail mark X -> mark tail X,
                                    tail ok X -> ok tail X,
                            take(X1, mark X2) -> mark take(X1, X2),
                            take(mark X1, X2) -> mark take(X1, X2),
                           take(ok X1, ok X2) -> ok take(X1, X2),
                           proper U12(X1, X2) -> U12(proper X1, proper X2),
                       proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                  proper tt() -> ok tt(),
                          proper pair(X1, X2) -> pair(proper X1, proper X2),
                          proper cons(X1, X2) -> cons(proper X1, proper X2),
                                 proper snd X -> snd proper X,
                      proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                           proper and(X1, X2) -> and(proper X1, proper X2),
                                 proper fst X -> fst proper X,
                                proper head X -> head proper X,
                            proper natsFrom X -> natsFrom proper X,
                                   proper s X -> s proper X,
                           proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper nil() -> ok nil(),
                                   proper 0() -> ok 0(),
                                proper tail X -> tail proper X,
                          proper take(X1, X2) -> take(proper X1, proper X2),
                                   top mark X -> top proper X,
                                     top ok X -> top active X}
            POLY:
             Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
             Interpretation:
              [U11](x0, x1, x2, x3) = x0 + x1 + x2 + x3,
              
              [U12](x0, x1) = x0 + x1,
              
              [splitAt](x0, x1) = x0 + x1,
              
              [pair](x0, x1) = x0 + x1,
              
              [cons](x0, x1) = x0 + x1,
              
              [afterNth](x0, x1) = x0 + x1,
              
              [and](x0, x1) = x0 + x1,
              
              [sel](x0, x1) = x0 + x1,
              
              [take](x0, x1) = x0 + 1,
              
              [mark](x0) = x0 + 1,
              
              [active](x0) = 0,
              
              [snd](x0) = x0,
              
              [fst](x0) = x0,
              
              [head](x0) = x0,
              
              [natsFrom](x0) = x0,
              
              [s](x0) = x0,
              
              [tail](x0) = x0 + 1,
              
              [proper](x0) = 0,
              
              [ok](x0) = x0 + 1,
              
              [top](x0) = 0,
              
              [tt] = 0,
              
              [nil] = 0,
              
              [0] = 0,
              
              [proper#](x0) = x0
             Strict:
              proper# tail X -> proper# X
              1 + 1X >= 0 + 1X
              proper# sel(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# sel(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
              proper# s X -> proper# X
              0 + 1X >= 0 + 1X
              proper# natsFrom X -> proper# X
              0 + 1X >= 0 + 1X
              proper# head X -> proper# X
              0 + 1X >= 0 + 1X
              proper# fst X -> proper# X
              0 + 1X >= 0 + 1X
              proper# and(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# and(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
              proper# afterNth(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# afterNth(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
              proper# snd X -> proper# X
              0 + 1X >= 0 + 1X
              proper# cons(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# cons(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
              proper# pair(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# pair(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
              proper# U11(X1, X2, X3, X4) -> proper# X4
              0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X4
              proper# U11(X1, X2, X3, X4) -> proper# X3
              0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X3
              proper# U11(X1, X2, X3, X4) -> proper# X2
              0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X2
              proper# U11(X1, X2, X3, X4) -> proper# X1
              0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X1
              proper# splitAt(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# splitAt(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
              proper# U12(X1, X2) -> proper# X2
              0 + 1X1 + 1X2 >= 0 + 1X2
              proper# U12(X1, X2) -> proper# X1
              0 + 1X1 + 1X2 >= 0 + 1X1
             Weak:
              top ok X -> top active X
              0 + 0X >= 0 + 0X
              top mark X -> top proper X
              0 + 0X >= 0 + 0X
              proper take(X1, X2) -> take(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
              proper tail X -> tail proper X
              0 + 0X >= 1 + 0X
              proper 0() -> ok 0()
              0 >= 1
              proper nil() -> ok nil()
              0 >= 1
              proper sel(X1, X2) -> sel(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              proper s X -> s proper X
              0 + 0X >= 0 + 0X
              proper natsFrom X -> natsFrom proper X
              0 + 0X >= 0 + 0X
              proper head X -> head proper X
              0 + 0X >= 0 + 0X
              proper fst X -> fst proper X
              0 + 0X >= 0 + 0X
              proper and(X1, X2) -> and(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              proper snd X -> snd proper X
              0 + 0X >= 0 + 0X
              proper cons(X1, X2) -> cons(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              proper pair(X1, X2) -> pair(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              proper tt() -> ok tt()
              0 >= 1
              proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
              0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              proper U12(X1, X2) -> U12(proper X1, proper X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              take(ok X1, ok X2) -> ok take(X1, X2)
              2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
              take(mark X1, X2) -> mark take(X1, X2)
              1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
              take(X1, mark X2) -> mark take(X1, X2)
              2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
              tail ok X -> ok tail X
              2 + 1X >= 2 + 1X
              tail mark X -> mark tail X
              2 + 1X >= 2 + 1X
              sel(ok X1, ok X2) -> ok sel(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              sel(mark X1, X2) -> mark sel(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              sel(X1, mark X2) -> mark sel(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              s ok X -> ok s X
              1 + 1X >= 1 + 1X
              s mark X -> mark s X
              1 + 1X >= 1 + 1X
              natsFrom ok X -> ok natsFrom X
              1 + 1X >= 1 + 1X
              natsFrom mark X -> mark natsFrom X
              1 + 1X >= 1 + 1X
              head ok X -> ok head X
              1 + 1X >= 1 + 1X
              head mark X -> mark head X
              1 + 1X >= 1 + 1X
              fst ok X -> ok fst X
              1 + 1X >= 1 + 1X
              fst mark X -> mark fst X
              1 + 1X >= 1 + 1X
              and(ok X1, ok X2) -> ok and(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              and(mark X1, X2) -> mark and(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              afterNth(mark X1, X2) -> mark afterNth(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              afterNth(X1, mark X2) -> mark afterNth(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              snd ok X -> ok snd X
              1 + 1X >= 1 + 1X
              snd mark X -> mark snd X
              1 + 1X >= 1 + 1X
              cons(ok X1, ok X2) -> ok cons(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              cons(mark X1, X2) -> mark cons(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              pair(ok X1, ok X2) -> ok pair(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              pair(mark X1, X2) -> mark pair(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              pair(X1, mark X2) -> mark pair(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
              4 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1 + 1X2 + 1X3 + 1X4
              U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
              1 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1 + 1X2 + 1X3 + 1X4
              active take(X1, X2) -> take(active X1, X2)
              0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
              active take(X1, X2) -> take(X1, active X2)
              0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
              active take(N, XS) -> mark fst splitAt(N, XS)
              0 + 0N + 0XS >= 1 + 1N + 1XS
              active tail cons(N, XS) -> mark XS
              0 + 0N + 0XS >= 1 + 1XS
              active tail X -> tail active X
              0 + 0X >= 1 + 0X
              active sel(X1, X2) -> sel(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              active sel(X1, X2) -> sel(X1, active X2)
              0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
              active sel(N, XS) -> mark head afterNth(N, XS)
              0 + 0N + 0XS >= 1 + 1N + 1XS
              active s X -> s active X
              0 + 0X >= 0 + 0X
              active natsFrom X -> natsFrom active X
              0 + 0X >= 0 + 0X
              active natsFrom N -> mark cons(N, natsFrom s N)
              0 + 0N >= 1 + 2N
              active head cons(N, XS) -> mark N
              0 + 0N + 0XS >= 1 + 1N
              active head X -> head active X
              0 + 0X >= 0 + 0X
              active fst pair(X, Y) -> mark X
              0 + 0X + 0Y >= 1 + 1X
              active fst X -> fst active X
              0 + 0X >= 0 + 0X
              active and(tt(), X) -> mark X
              0 + 0X >= 1 + 1X
              active and(X1, X2) -> and(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              active afterNth(X1, X2) -> afterNth(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              active afterNth(X1, X2) -> afterNth(X1, active X2)
              0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
              active afterNth(N, XS) -> mark snd splitAt(N, XS)
              0 + 0N + 0XS >= 1 + 1N + 1XS
              active snd pair(X, Y) -> mark Y
              0 + 0X + 0Y >= 1 + 1Y
              active snd X -> snd active X
              0 + 0X >= 0 + 0X
              active cons(X1, X2) -> cons(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              active pair(X1, X2) -> pair(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              active pair(X1, X2) -> pair(X1, active X2)
              0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
              active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
              0 + 0N + 0XS + 0X >= 1 + 1N + 1XS + 1X
              active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
              0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 1X2 + 1X3 + 1X4
              active splitAt(0(), XS) -> mark pair(nil(), XS)
              0 + 0XS >= 1 + 1XS
              active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
              0 + 0N + 0XS + 0X >= 1 + 1N + 1XS + 1X
              active splitAt(X1, X2) -> splitAt(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              active splitAt(X1, X2) -> splitAt(X1, active X2)
              0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
              active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
              0 + 0X + 0YS + 0ZS >= 1 + 1X + 1YS + 1ZS
              active U12(X1, X2) -> U12(active X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
              splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              splitAt(mark X1, X2) -> mark splitAt(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              splitAt(X1, mark X2) -> mark splitAt(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              U12(ok X1, ok X2) -> ok U12(X1, X2)
              2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              U12(mark X1, X2) -> mark U12(X1, X2)
              1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            SCCS (1):
             Scc:
              {        proper# U12(X1, X2) -> proper# X1,
                       proper# U12(X1, X2) -> proper# X2,
                   proper# splitAt(X1, X2) -> proper# X1,
                   proper# splitAt(X1, X2) -> proper# X2,
               proper# U11(X1, X2, X3, X4) -> proper# X1,
               proper# U11(X1, X2, X3, X4) -> proper# X2,
               proper# U11(X1, X2, X3, X4) -> proper# X3,
               proper# U11(X1, X2, X3, X4) -> proper# X4,
                      proper# pair(X1, X2) -> proper# X1,
                      proper# pair(X1, X2) -> proper# X2,
                      proper# cons(X1, X2) -> proper# X1,
                      proper# cons(X1, X2) -> proper# X2,
                             proper# snd X -> proper# X,
                  proper# afterNth(X1, X2) -> proper# X1,
                  proper# afterNth(X1, X2) -> proper# X2,
                       proper# and(X1, X2) -> proper# X1,
                       proper# and(X1, X2) -> proper# X2,
                             proper# fst X -> proper# X,
                            proper# head X -> proper# X,
                        proper# natsFrom X -> proper# X,
                               proper# s X -> proper# X,
                       proper# sel(X1, X2) -> proper# X1,
                       proper# sel(X1, X2) -> proper# X2}
             
             SCC (23):
              Strict:
               {        proper# U12(X1, X2) -> proper# X1,
                        proper# U12(X1, X2) -> proper# X2,
                    proper# splitAt(X1, X2) -> proper# X1,
                    proper# splitAt(X1, X2) -> proper# X2,
                proper# U11(X1, X2, X3, X4) -> proper# X1,
                proper# U11(X1, X2, X3, X4) -> proper# X2,
                proper# U11(X1, X2, X3, X4) -> proper# X3,
                proper# U11(X1, X2, X3, X4) -> proper# X4,
                       proper# pair(X1, X2) -> proper# X1,
                       proper# pair(X1, X2) -> proper# X2,
                       proper# cons(X1, X2) -> proper# X1,
                       proper# cons(X1, X2) -> proper# X2,
                              proper# snd X -> proper# X,
                   proper# afterNth(X1, X2) -> proper# X1,
                   proper# afterNth(X1, X2) -> proper# X2,
                        proper# and(X1, X2) -> proper# X1,
                        proper# and(X1, X2) -> proper# X2,
                              proper# fst X -> proper# X,
                             proper# head X -> proper# X,
                         proper# natsFrom X -> proper# X,
                                proper# s X -> proper# X,
                        proper# sel(X1, X2) -> proper# X1,
                        proper# sel(X1, X2) -> proper# X2}
              Weak:
              {                U12(mark X1, X2) -> mark U12(X1, X2),
                              U12(ok X1, ok X2) -> ok U12(X1, X2),
                           splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                           splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                          splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                             active U12(X1, X2) -> U12(active X1, X2),
                    active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                         active splitAt(X1, X2) -> splitAt(X1, active X2),
                         active splitAt(X1, X2) -> splitAt(active X1, X2),
               active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                        active splitAt(0(), XS) -> mark pair(nil(), XS),
                     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                            active pair(X1, X2) -> pair(X1, active X2),
                            active pair(X1, X2) -> pair(active X1, X2),
                            active cons(X1, X2) -> cons(active X1, X2),
                                   active snd X -> snd active X,
                          active snd pair(X, Y) -> mark Y,
                         active afterNth(N, XS) -> mark snd splitAt(N, XS),
                        active afterNth(X1, X2) -> afterNth(X1, active X2),
                        active afterNth(X1, X2) -> afterNth(active X1, X2),
                             active and(X1, X2) -> and(active X1, X2),
                            active and(tt(), X) -> mark X,
                                   active fst X -> fst active X,
                          active fst pair(X, Y) -> mark X,
                                  active head X -> head active X,
                        active head cons(N, XS) -> mark N,
                              active natsFrom N -> mark cons(N, natsFrom s N),
                              active natsFrom X -> natsFrom active X,
                                     active s X -> s active X,
                              active sel(N, XS) -> mark head afterNth(N, XS),
                             active sel(X1, X2) -> sel(X1, active X2),
                             active sel(X1, X2) -> sel(active X1, X2),
                                  active tail X -> tail active X,
                        active tail cons(N, XS) -> mark XS,
                             active take(N, XS) -> mark fst splitAt(N, XS),
                            active take(X1, X2) -> take(X1, active X2),
                            active take(X1, X2) -> take(active X1, X2),
                       U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
                U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                              pair(X1, mark X2) -> mark pair(X1, X2),
                              pair(mark X1, X2) -> mark pair(X1, X2),
                             pair(ok X1, ok X2) -> ok pair(X1, X2),
                              cons(mark X1, X2) -> mark cons(X1, X2),
                             cons(ok X1, ok X2) -> ok cons(X1, X2),
                                     snd mark X -> mark snd X,
                                       snd ok X -> ok snd X,
                          afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                          afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                         afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                               and(mark X1, X2) -> mark and(X1, X2),
                              and(ok X1, ok X2) -> ok and(X1, X2),
                                     fst mark X -> mark fst X,
                                       fst ok X -> ok fst X,
                                    head mark X -> mark head X,
                                      head ok X -> ok head X,
                                natsFrom mark X -> mark natsFrom X,
                                  natsFrom ok X -> ok natsFrom X,
                                       s mark X -> mark s X,
                                         s ok X -> ok s X,
                               sel(X1, mark X2) -> mark sel(X1, X2),
                               sel(mark X1, X2) -> mark sel(X1, X2),
                              sel(ok X1, ok X2) -> ok sel(X1, X2),
                                    tail mark X -> mark tail X,
                                      tail ok X -> ok tail X,
                              take(X1, mark X2) -> mark take(X1, X2),
                              take(mark X1, X2) -> mark take(X1, X2),
                             take(ok X1, ok X2) -> ok take(X1, X2),
                             proper U12(X1, X2) -> U12(proper X1, proper X2),
                         proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                    proper tt() -> ok tt(),
                            proper pair(X1, X2) -> pair(proper X1, proper X2),
                            proper cons(X1, X2) -> cons(proper X1, proper X2),
                                   proper snd X -> snd proper X,
                        proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                             proper and(X1, X2) -> and(proper X1, proper X2),
                                   proper fst X -> fst proper X,
                                  proper head X -> head proper X,
                              proper natsFrom X -> natsFrom proper X,
                                     proper s X -> s proper X,
                             proper sel(X1, X2) -> sel(proper X1, proper X2),
                                   proper nil() -> ok nil(),
                                     proper 0() -> ok 0(),
                                  proper tail X -> tail proper X,
                            proper take(X1, X2) -> take(proper X1, proper X2),
                                     top mark X -> top proper X,
                                       top ok X -> top active X}
              POLY:
               Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
               Interpretation:
                [U11](x0, x1, x2, x3) = x0 + x1 + x2 + x3,
                
                [U12](x0, x1) = x0 + x1,
                
                [splitAt](x0, x1) = x0 + x1,
                
                [pair](x0, x1) = x0 + x1,
                
                [cons](x0, x1) = x0 + x1,
                
                [afterNth](x0, x1) = x0 + x1,
                
                [and](x0, x1) = x0 + x1,
                
                [sel](x0, x1) = x0 + x1 + 1,
                
                [take](x0, x1) = x0 + 1,
                
                [mark](x0) = x0 + 1,
                
                [active](x0) = 0,
                
                [snd](x0) = x0,
                
                [fst](x0) = x0,
                
                [head](x0) = x0,
                
                [natsFrom](x0) = x0,
                
                [s](x0) = x0,
                
                [tail](x0) = 0,
                
                [proper](x0) = 0,
                
                [ok](x0) = x0 + 1,
                
                [top](x0) = 0,
                
                [tt] = 0,
                
                [nil] = 0,
                
                [0] = 0,
                
                [proper#](x0) = x0
               Strict:
                proper# sel(X1, X2) -> proper# X2
                1 + 1X1 + 1X2 >= 0 + 1X2
                proper# sel(X1, X2) -> proper# X1
                1 + 1X1 + 1X2 >= 0 + 1X1
                proper# s X -> proper# X
                0 + 1X >= 0 + 1X
                proper# natsFrom X -> proper# X
                0 + 1X >= 0 + 1X
                proper# head X -> proper# X
                0 + 1X >= 0 + 1X
                proper# fst X -> proper# X
                0 + 1X >= 0 + 1X
                proper# and(X1, X2) -> proper# X2
                0 + 1X1 + 1X2 >= 0 + 1X2
                proper# and(X1, X2) -> proper# X1
                0 + 1X1 + 1X2 >= 0 + 1X1
                proper# afterNth(X1, X2) -> proper# X2
                0 + 1X1 + 1X2 >= 0 + 1X2
                proper# afterNth(X1, X2) -> proper# X1
                0 + 1X1 + 1X2 >= 0 + 1X1
                proper# snd X -> proper# X
                0 + 1X >= 0 + 1X
                proper# cons(X1, X2) -> proper# X2
                0 + 1X1 + 1X2 >= 0 + 1X2
                proper# cons(X1, X2) -> proper# X1
                0 + 1X1 + 1X2 >= 0 + 1X1
                proper# pair(X1, X2) -> proper# X2
                0 + 1X1 + 1X2 >= 0 + 1X2
                proper# pair(X1, X2) -> proper# X1
                0 + 1X1 + 1X2 >= 0 + 1X1
                proper# U11(X1, X2, X3, X4) -> proper# X4
                0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X4
                proper# U11(X1, X2, X3, X4) -> proper# X3
                0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X3
                proper# U11(X1, X2, X3, X4) -> proper# X2
                0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X2
                proper# U11(X1, X2, X3, X4) -> proper# X1
                0 + 1X1 + 1X2 + 1X3 + 1X4 >= 0 + 1X1
                proper# splitAt(X1, X2) -> proper# X2
                0 + 1X1 + 1X2 >= 0 + 1X2
                proper# splitAt(X1, X2) -> proper# X1
                0 + 1X1 + 1X2 >= 0 + 1X1
                proper# U12(X1, X2) -> proper# X2
                0 + 1X1 + 1X2 >= 0 + 1X2
                proper# U12(X1, X2) -> proper# X1
                0 + 1X1 + 1X2 >= 0 + 1X1
               Weak:
                top ok X -> top active X
                0 + 0X >= 0 + 0X
                top mark X -> top proper X
                0 + 0X >= 0 + 0X
                proper take(X1, X2) -> take(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                proper tail X -> tail proper X
                0 + 0X >= 0 + 0X
                proper 0() -> ok 0()
                0 >= 1
                proper nil() -> ok nil()
                0 >= 1
                proper sel(X1, X2) -> sel(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                proper s X -> s proper X
                0 + 0X >= 0 + 0X
                proper natsFrom X -> natsFrom proper X
                0 + 0X >= 0 + 0X
                proper head X -> head proper X
                0 + 0X >= 0 + 0X
                proper fst X -> fst proper X
                0 + 0X >= 0 + 0X
                proper and(X1, X2) -> and(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                proper snd X -> snd proper X
                0 + 0X >= 0 + 0X
                proper cons(X1, X2) -> cons(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                proper pair(X1, X2) -> pair(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                proper tt() -> ok tt()
                0 >= 1
                proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
                0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
                proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                proper U12(X1, X2) -> U12(proper X1, proper X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                take(ok X1, ok X2) -> ok take(X1, X2)
                2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                take(mark X1, X2) -> mark take(X1, X2)
                1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                take(X1, mark X2) -> mark take(X1, X2)
                2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                tail ok X -> ok tail X
                0 + 0X >= 1 + 0X
                tail mark X -> mark tail X
                0 + 0X >= 1 + 0X
                sel(ok X1, ok X2) -> ok sel(X1, X2)
                3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                sel(mark X1, X2) -> mark sel(X1, X2)
                2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                sel(X1, mark X2) -> mark sel(X1, X2)
                2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                s ok X -> ok s X
                1 + 1X >= 1 + 1X
                s mark X -> mark s X
                1 + 1X >= 1 + 1X
                natsFrom ok X -> ok natsFrom X
                1 + 1X >= 1 + 1X
                natsFrom mark X -> mark natsFrom X
                1 + 1X >= 1 + 1X
                head ok X -> ok head X
                1 + 1X >= 1 + 1X
                head mark X -> mark head X
                1 + 1X >= 1 + 1X
                fst ok X -> ok fst X
                1 + 1X >= 1 + 1X
                fst mark X -> mark fst X
                1 + 1X >= 1 + 1X
                and(ok X1, ok X2) -> ok and(X1, X2)
                2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                and(mark X1, X2) -> mark and(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
                2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                afterNth(mark X1, X2) -> mark afterNth(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                afterNth(X1, mark X2) -> mark afterNth(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                snd ok X -> ok snd X
                1 + 1X >= 1 + 1X
                snd mark X -> mark snd X
                1 + 1X >= 1 + 1X
                cons(ok X1, ok X2) -> ok cons(X1, X2)
                2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                cons(mark X1, X2) -> mark cons(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                pair(ok X1, ok X2) -> ok pair(X1, X2)
                2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                pair(mark X1, X2) -> mark pair(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                pair(X1, mark X2) -> mark pair(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
                4 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1 + 1X2 + 1X3 + 1X4
                U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
                1 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1 + 1X2 + 1X3 + 1X4
                active take(X1, X2) -> take(active X1, X2)
                0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
                active take(X1, X2) -> take(X1, active X2)
                0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                active take(N, XS) -> mark fst splitAt(N, XS)
                0 + 0N + 0XS >= 1 + 1N + 1XS
                active tail cons(N, XS) -> mark XS
                0 + 0N + 0XS >= 1 + 1XS
                active tail X -> tail active X
                0 + 0X >= 0 + 0X
                active sel(X1, X2) -> sel(active X1, X2)
                0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
                active sel(X1, X2) -> sel(X1, active X2)
                0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
                active sel(N, XS) -> mark head afterNth(N, XS)
                0 + 0N + 0XS >= 1 + 1N + 1XS
                active s X -> s active X
                0 + 0X >= 0 + 0X
                active natsFrom X -> natsFrom active X
                0 + 0X >= 0 + 0X
                active natsFrom N -> mark cons(N, natsFrom s N)
                0 + 0N >= 1 + 2N
                active head cons(N, XS) -> mark N
                0 + 0N + 0XS >= 1 + 1N
                active head X -> head active X
                0 + 0X >= 0 + 0X
                active fst pair(X, Y) -> mark X
                0 + 0X + 0Y >= 1 + 1X
                active fst X -> fst active X
                0 + 0X >= 0 + 0X
                active and(tt(), X) -> mark X
                0 + 0X >= 1 + 1X
                active and(X1, X2) -> and(active X1, X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                active afterNth(X1, X2) -> afterNth(active X1, X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                active afterNth(X1, X2) -> afterNth(X1, active X2)
                0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
                active afterNth(N, XS) -> mark snd splitAt(N, XS)
                0 + 0N + 0XS >= 1 + 1N + 1XS
                active snd pair(X, Y) -> mark Y
                0 + 0X + 0Y >= 1 + 1Y
                active snd X -> snd active X
                0 + 0X >= 0 + 0X
                active cons(X1, X2) -> cons(active X1, X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                active pair(X1, X2) -> pair(active X1, X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                active pair(X1, X2) -> pair(X1, active X2)
                0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
                active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
                0 + 0N + 0XS + 0X >= 1 + 1N + 1XS + 1X
                active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
                0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 1X2 + 1X3 + 1X4
                active splitAt(0(), XS) -> mark pair(nil(), XS)
                0 + 0XS >= 1 + 1XS
                active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
                0 + 0N + 0XS + 0X >= 1 + 1N + 1XS + 1X
                active splitAt(X1, X2) -> splitAt(active X1, X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                active splitAt(X1, X2) -> splitAt(X1, active X2)
                0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
                active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
                0 + 0X + 0YS + 0ZS >= 1 + 1X + 1YS + 1ZS
                active U12(X1, X2) -> U12(active X1, X2)
                0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
                2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                splitAt(mark X1, X2) -> mark splitAt(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                splitAt(X1, mark X2) -> mark splitAt(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                U12(ok X1, ok X2) -> ok U12(X1, X2)
                2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                U12(mark X1, X2) -> mark U12(X1, X2)
                1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
              SCCS (1):
               Scc:
                {        proper# U12(X1, X2) -> proper# X1,
                         proper# U12(X1, X2) -> proper# X2,
                     proper# splitAt(X1, X2) -> proper# X1,
                     proper# splitAt(X1, X2) -> proper# X2,
                 proper# U11(X1, X2, X3, X4) -> proper# X1,
                 proper# U11(X1, X2, X3, X4) -> proper# X2,
                 proper# U11(X1, X2, X3, X4) -> proper# X3,
                 proper# U11(X1, X2, X3, X4) -> proper# X4,
                        proper# pair(X1, X2) -> proper# X1,
                        proper# pair(X1, X2) -> proper# X2,
                        proper# cons(X1, X2) -> proper# X1,
                        proper# cons(X1, X2) -> proper# X2,
                               proper# snd X -> proper# X,
                    proper# afterNth(X1, X2) -> proper# X1,
                    proper# afterNth(X1, X2) -> proper# X2,
                         proper# and(X1, X2) -> proper# X1,
                         proper# and(X1, X2) -> proper# X2,
                               proper# fst X -> proper# X,
                              proper# head X -> proper# X,
                          proper# natsFrom X -> proper# X,
                                 proper# s X -> proper# X}
               
               SCC (21):
                Strict:
                 {        proper# U12(X1, X2) -> proper# X1,
                          proper# U12(X1, X2) -> proper# X2,
                      proper# splitAt(X1, X2) -> proper# X1,
                      proper# splitAt(X1, X2) -> proper# X2,
                  proper# U11(X1, X2, X3, X4) -> proper# X1,
                  proper# U11(X1, X2, X3, X4) -> proper# X2,
                  proper# U11(X1, X2, X3, X4) -> proper# X3,
                  proper# U11(X1, X2, X3, X4) -> proper# X4,
                         proper# pair(X1, X2) -> proper# X1,
                         proper# pair(X1, X2) -> proper# X2,
                         proper# cons(X1, X2) -> proper# X1,
                         proper# cons(X1, X2) -> proper# X2,
                                proper# snd X -> proper# X,
                     proper# afterNth(X1, X2) -> proper# X1,
                     proper# afterNth(X1, X2) -> proper# X2,
                          proper# and(X1, X2) -> proper# X1,
                          proper# and(X1, X2) -> proper# X2,
                                proper# fst X -> proper# X,
                               proper# head X -> proper# X,
                           proper# natsFrom X -> proper# X,
                                  proper# s X -> proper# X}
                Weak:
                {                U12(mark X1, X2) -> mark U12(X1, X2),
                                U12(ok X1, ok X2) -> ok U12(X1, X2),
                             splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                             splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                            splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                               active U12(X1, X2) -> U12(active X1, X2),
                      active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                           active splitAt(X1, X2) -> splitAt(X1, active X2),
                           active splitAt(X1, X2) -> splitAt(active X1, X2),
                 active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                          active splitAt(0(), XS) -> mark pair(nil(), XS),
                       active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                       active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                              active pair(X1, X2) -> pair(X1, active X2),
                              active pair(X1, X2) -> pair(active X1, X2),
                              active cons(X1, X2) -> cons(active X1, X2),
                                     active snd X -> snd active X,
                            active snd pair(X, Y) -> mark Y,
                           active afterNth(N, XS) -> mark snd splitAt(N, XS),
                          active afterNth(X1, X2) -> afterNth(X1, active X2),
                          active afterNth(X1, X2) -> afterNth(active X1, X2),
                               active and(X1, X2) -> and(active X1, X2),
                              active and(tt(), X) -> mark X,
                                     active fst X -> fst active X,
                            active fst pair(X, Y) -> mark X,
                                    active head X -> head active X,
                          active head cons(N, XS) -> mark N,
                                active natsFrom N -> mark cons(N, natsFrom s N),
                                active natsFrom X -> natsFrom active X,
                                       active s X -> s active X,
                                active sel(N, XS) -> mark head afterNth(N, XS),
                               active sel(X1, X2) -> sel(X1, active X2),
                               active sel(X1, X2) -> sel(active X1, X2),
                                    active tail X -> tail active X,
                          active tail cons(N, XS) -> mark XS,
                               active take(N, XS) -> mark fst splitAt(N, XS),
                              active take(X1, X2) -> take(X1, active X2),
                              active take(X1, X2) -> take(active X1, X2),
                         U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
                  U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                                pair(X1, mark X2) -> mark pair(X1, X2),
                                pair(mark X1, X2) -> mark pair(X1, X2),
                               pair(ok X1, ok X2) -> ok pair(X1, X2),
                                cons(mark X1, X2) -> mark cons(X1, X2),
                               cons(ok X1, ok X2) -> ok cons(X1, X2),
                                       snd mark X -> mark snd X,
                                         snd ok X -> ok snd X,
                            afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                            afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                           afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                                 and(mark X1, X2) -> mark and(X1, X2),
                                and(ok X1, ok X2) -> ok and(X1, X2),
                                       fst mark X -> mark fst X,
                                         fst ok X -> ok fst X,
                                      head mark X -> mark head X,
                                        head ok X -> ok head X,
                                  natsFrom mark X -> mark natsFrom X,
                                    natsFrom ok X -> ok natsFrom X,
                                         s mark X -> mark s X,
                                           s ok X -> ok s X,
                                 sel(X1, mark X2) -> mark sel(X1, X2),
                                 sel(mark X1, X2) -> mark sel(X1, X2),
                                sel(ok X1, ok X2) -> ok sel(X1, X2),
                                      tail mark X -> mark tail X,
                                        tail ok X -> ok tail X,
                                take(X1, mark X2) -> mark take(X1, X2),
                                take(mark X1, X2) -> mark take(X1, X2),
                               take(ok X1, ok X2) -> ok take(X1, X2),
                               proper U12(X1, X2) -> U12(proper X1, proper X2),
                           proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                       proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                      proper tt() -> ok tt(),
                              proper pair(X1, X2) -> pair(proper X1, proper X2),
                              proper cons(X1, X2) -> cons(proper X1, proper X2),
                                     proper snd X -> snd proper X,
                          proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                               proper and(X1, X2) -> and(proper X1, proper X2),
                                     proper fst X -> fst proper X,
                                    proper head X -> head proper X,
                                proper natsFrom X -> natsFrom proper X,
                                       proper s X -> s proper X,
                               proper sel(X1, X2) -> sel(proper X1, proper X2),
                                     proper nil() -> ok nil(),
                                       proper 0() -> ok 0(),
                                    proper tail X -> tail proper X,
                              proper take(X1, X2) -> take(proper X1, proper X2),
                                       top mark X -> top proper X,
                                         top ok X -> top active X}
                POLY:
                 Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
                 Interpretation:
                  [U11](x0, x1, x2, x3) = x0 + x1 + x2 + x3 + 1,
                  
                  [U12](x0, x1) = x0 + x1 + 1,
                  
                  [splitAt](x0, x1) = x0 + x1,
                  
                  [pair](x0, x1) = x0 + x1 + 1,
                  
                  [cons](x0, x1) = x0 + x1 + 1,
                  
                  [afterNth](x0, x1) = x0 + x1 + 1,
                  
                  [and](x0, x1) = x0 + x1 + 1,
                  
                  [sel](x0, x1) = x0 + 1,
                  
                  [take](x0, x1) = x0 + x1 + 1,
                  
                  [mark](x0) = x0 + 1,
                  
                  [active](x0) = x0 + 1,
                  
                  [snd](x0) = x0 + 1,
                  
                  [fst](x0) = x0 + 1,
                  
                  [head](x0) = x0 + 1,
                  
                  [natsFrom](x0) = x0 + 1,
                  
                  [s](x0) = x0 + 1,
                  
                  [tail](x0) = 1,
                  
                  [proper](x0) = x0,
                  
                  [ok](x0) = 0,
                  
                  [top](x0) = 0,
                  
                  [tt] = 1,
                  
                  [nil] = 1,
                  
                  [0] = 1,
                  
                  [proper#](x0) = x0 + 1
                 Strict:
                  proper# s X -> proper# X
                  2 + 1X >= 1 + 1X
                  proper# natsFrom X -> proper# X
                  2 + 1X >= 1 + 1X
                  proper# head X -> proper# X
                  2 + 1X >= 1 + 1X
                  proper# fst X -> proper# X
                  2 + 1X >= 1 + 1X
                  proper# and(X1, X2) -> proper# X2
                  2 + 1X1 + 1X2 >= 1 + 1X2
                  proper# and(X1, X2) -> proper# X1
                  2 + 1X1 + 1X2 >= 1 + 1X1
                  proper# afterNth(X1, X2) -> proper# X2
                  2 + 1X1 + 1X2 >= 1 + 1X2
                  proper# afterNth(X1, X2) -> proper# X1
                  2 + 1X1 + 1X2 >= 1 + 1X1
                  proper# snd X -> proper# X
                  2 + 1X >= 1 + 1X
                  proper# cons(X1, X2) -> proper# X2
                  2 + 1X1 + 1X2 >= 1 + 1X2
                  proper# cons(X1, X2) -> proper# X1
                  2 + 1X1 + 1X2 >= 1 + 1X1
                  proper# pair(X1, X2) -> proper# X2
                  2 + 1X1 + 1X2 >= 1 + 1X2
                  proper# pair(X1, X2) -> proper# X1
                  2 + 1X1 + 1X2 >= 1 + 1X1
                  proper# U11(X1, X2, X3, X4) -> proper# X4
                  2 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X4
                  proper# U11(X1, X2, X3, X4) -> proper# X3
                  2 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X3
                  proper# U11(X1, X2, X3, X4) -> proper# X2
                  2 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X2
                  proper# U11(X1, X2, X3, X4) -> proper# X1
                  2 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1
                  proper# splitAt(X1, X2) -> proper# X2
                  1 + 1X1 + 1X2 >= 1 + 1X2
                  proper# splitAt(X1, X2) -> proper# X1
                  1 + 1X1 + 1X2 >= 1 + 1X1
                  proper# U12(X1, X2) -> proper# X2
                  2 + 1X1 + 1X2 >= 1 + 1X2
                  proper# U12(X1, X2) -> proper# X1
                  2 + 1X1 + 1X2 >= 1 + 1X1
                 Weak:
                  top ok X -> top active X
                  0 + 0X >= 0 + 0X
                  top mark X -> top proper X
                  0 + 0X >= 0 + 0X
                  proper take(X1, X2) -> take(proper X1, proper X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  proper tail X -> tail proper X
                  1 + 0X >= 1 + 0X
                  proper 0() -> ok 0()
                  1 >= 0
                  proper nil() -> ok nil()
                  1 >= 0
                  proper sel(X1, X2) -> sel(proper X1, proper X2)
                  1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                  proper s X -> s proper X
                  1 + 1X >= 1 + 1X
                  proper natsFrom X -> natsFrom proper X
                  1 + 1X >= 1 + 1X
                  proper head X -> head proper X
                  1 + 1X >= 1 + 1X
                  proper fst X -> fst proper X
                  1 + 1X >= 1 + 1X
                  proper and(X1, X2) -> and(proper X1, proper X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  proper snd X -> snd proper X
                  1 + 1X >= 1 + 1X
                  proper cons(X1, X2) -> cons(proper X1, proper X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  proper pair(X1, X2) -> pair(proper X1, proper X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  proper tt() -> ok tt()
                  1 >= 0
                  proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
                  1 + 1X1 + 1X2 + 1X3 + 1X4 >= 1 + 1X1 + 1X2 + 1X3 + 1X4
                  proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
                  0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
                  proper U12(X1, X2) -> U12(proper X1, proper X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  take(ok X1, ok X2) -> ok take(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  take(mark X1, X2) -> mark take(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  take(X1, mark X2) -> mark take(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  tail ok X -> ok tail X
                  1 + 0X >= 0 + 0X
                  tail mark X -> mark tail X
                  1 + 0X >= 2 + 0X
                  sel(ok X1, ok X2) -> ok sel(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  sel(mark X1, X2) -> mark sel(X1, X2)
                  1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                  sel(X1, mark X2) -> mark sel(X1, X2)
                  2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                  s ok X -> ok s X
                  1 + 0X >= 0 + 0X
                  s mark X -> mark s X
                  2 + 1X >= 2 + 1X
                  natsFrom ok X -> ok natsFrom X
                  1 + 0X >= 0 + 0X
                  natsFrom mark X -> mark natsFrom X
                  2 + 1X >= 2 + 1X
                  head ok X -> ok head X
                  1 + 0X >= 0 + 0X
                  head mark X -> mark head X
                  2 + 1X >= 2 + 1X
                  fst ok X -> ok fst X
                  1 + 0X >= 0 + 0X
                  fst mark X -> mark fst X
                  2 + 1X >= 2 + 1X
                  and(ok X1, ok X2) -> ok and(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  and(mark X1, X2) -> mark and(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  afterNth(mark X1, X2) -> mark afterNth(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  afterNth(X1, mark X2) -> mark afterNth(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  snd ok X -> ok snd X
                  1 + 0X >= 0 + 0X
                  snd mark X -> mark snd X
                  2 + 1X >= 2 + 1X
                  cons(ok X1, ok X2) -> ok cons(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  cons(mark X1, X2) -> mark cons(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  pair(ok X1, ok X2) -> ok pair(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  pair(mark X1, X2) -> mark pair(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  pair(X1, mark X2) -> mark pair(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
                  1 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
                  U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
                  2 + 1X1 + 1X2 + 1X3 + 1X4 >= 2 + 1X1 + 1X2 + 1X3 + 1X4
                  active take(X1, X2) -> take(active X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active take(X1, X2) -> take(X1, active X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active take(N, XS) -> mark fst splitAt(N, XS)
                  2 + 1N + 1XS >= 2 + 1N + 1XS
                  active tail cons(N, XS) -> mark XS
                  2 + 0N + 0XS >= 1 + 1XS
                  active tail X -> tail active X
                  2 + 0X >= 1 + 0X
                  active sel(X1, X2) -> sel(active X1, X2)
                  2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                  active sel(X1, X2) -> sel(X1, active X2)
                  2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                  active sel(N, XS) -> mark head afterNth(N, XS)
                  2 + 0N + 1XS >= 3 + 1N + 1XS
                  active s X -> s active X
                  2 + 1X >= 2 + 1X
                  active natsFrom X -> natsFrom active X
                  2 + 1X >= 2 + 1X
                  active natsFrom N -> mark cons(N, natsFrom s N)
                  2 + 1N >= 4 + 2N
                  active head cons(N, XS) -> mark N
                  3 + 1N + 1XS >= 1 + 1N
                  active head X -> head active X
                  2 + 1X >= 2 + 1X
                  active fst pair(X, Y) -> mark X
                  3 + 1X + 1Y >= 1 + 1X
                  active fst X -> fst active X
                  2 + 1X >= 2 + 1X
                  active and(tt(), X) -> mark X
                  3 + 1X >= 1 + 1X
                  active and(X1, X2) -> and(active X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active afterNth(X1, X2) -> afterNth(active X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active afterNth(X1, X2) -> afterNth(X1, active X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active afterNth(N, XS) -> mark snd splitAt(N, XS)
                  2 + 1N + 1XS >= 2 + 1N + 1XS
                  active snd pair(X, Y) -> mark Y
                  3 + 1X + 1Y >= 1 + 1Y
                  active snd X -> snd active X
                  2 + 1X >= 2 + 1X
                  active cons(X1, X2) -> cons(active X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active pair(X1, X2) -> pair(active X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active pair(X1, X2) -> pair(X1, active X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
                  3 + 1N + 1XS + 1X >= 2 + 1N + 1XS + 1X
                  active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
                  2 + 1X1 + 1X2 + 1X3 + 1X4 >= 2 + 1X1 + 1X2 + 1X3 + 1X4
                  active splitAt(0(), XS) -> mark pair(nil(), XS)
                  2 + 1XS >= 3 + 1XS
                  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
                  3 + 1N + 1XS + 1X >= 3 + 1N + 1XS + 1X
                  active splitAt(X1, X2) -> splitAt(active X1, X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  active splitAt(X1, X2) -> splitAt(X1, active X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
                  3 + 1X + 1YS + 1ZS >= 3 + 1X + 1YS + 1ZS
                  active U12(X1, X2) -> U12(active X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                  splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
                  0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  splitAt(mark X1, X2) -> mark splitAt(X1, X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  splitAt(X1, mark X2) -> mark splitAt(X1, X2)
                  1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                  U12(ok X1, ok X2) -> ok U12(X1, X2)
                  1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                  U12(mark X1, X2) -> mark U12(X1, X2)
                  2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                SCCS (1):
                 Scc:
                  {proper# splitAt(X1, X2) -> proper# X1,
                   proper# splitAt(X1, X2) -> proper# X2}
                 
                 SCC (2):
                  Strict:
                   {proper# splitAt(X1, X2) -> proper# X1,
                    proper# splitAt(X1, X2) -> proper# X2}
                  Weak:
                  {                U12(mark X1, X2) -> mark U12(X1, X2),
                                  U12(ok X1, ok X2) -> ok U12(X1, X2),
                               splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                               splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                              splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                                 active U12(X1, X2) -> U12(active X1, X2),
                        active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                             active splitAt(X1, X2) -> splitAt(X1, active X2),
                             active splitAt(X1, X2) -> splitAt(active X1, X2),
                   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                            active splitAt(0(), XS) -> mark pair(nil(), XS),
                         active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                                active pair(X1, X2) -> pair(X1, active X2),
                                active pair(X1, X2) -> pair(active X1, X2),
                                active cons(X1, X2) -> cons(active X1, X2),
                                       active snd X -> snd active X,
                              active snd pair(X, Y) -> mark Y,
                             active afterNth(N, XS) -> mark snd splitAt(N, XS),
                            active afterNth(X1, X2) -> afterNth(X1, active X2),
                            active afterNth(X1, X2) -> afterNth(active X1, X2),
                                 active and(X1, X2) -> and(active X1, X2),
                                active and(tt(), X) -> mark X,
                                       active fst X -> fst active X,
                              active fst pair(X, Y) -> mark X,
                                      active head X -> head active X,
                            active head cons(N, XS) -> mark N,
                                  active natsFrom N -> mark cons(N, natsFrom s N),
                                  active natsFrom X -> natsFrom active X,
                                         active s X -> s active X,
                                  active sel(N, XS) -> mark head afterNth(N, XS),
                                 active sel(X1, X2) -> sel(X1, active X2),
                                 active sel(X1, X2) -> sel(active X1, X2),
                                      active tail X -> tail active X,
                            active tail cons(N, XS) -> mark XS,
                                 active take(N, XS) -> mark fst splitAt(N, XS),
                                active take(X1, X2) -> take(X1, active X2),
                                active take(X1, X2) -> take(active X1, X2),
                           U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
                    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                                  pair(X1, mark X2) -> mark pair(X1, X2),
                                  pair(mark X1, X2) -> mark pair(X1, X2),
                                 pair(ok X1, ok X2) -> ok pair(X1, X2),
                                  cons(mark X1, X2) -> mark cons(X1, X2),
                                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                                         snd mark X -> mark snd X,
                                           snd ok X -> ok snd X,
                              afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                              afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                             afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                                   and(mark X1, X2) -> mark and(X1, X2),
                                  and(ok X1, ok X2) -> ok and(X1, X2),
                                         fst mark X -> mark fst X,
                                           fst ok X -> ok fst X,
                                        head mark X -> mark head X,
                                          head ok X -> ok head X,
                                    natsFrom mark X -> mark natsFrom X,
                                      natsFrom ok X -> ok natsFrom X,
                                           s mark X -> mark s X,
                                             s ok X -> ok s X,
                                   sel(X1, mark X2) -> mark sel(X1, X2),
                                   sel(mark X1, X2) -> mark sel(X1, X2),
                                  sel(ok X1, ok X2) -> ok sel(X1, X2),
                                        tail mark X -> mark tail X,
                                          tail ok X -> ok tail X,
                                  take(X1, mark X2) -> mark take(X1, X2),
                                  take(mark X1, X2) -> mark take(X1, X2),
                                 take(ok X1, ok X2) -> ok take(X1, X2),
                                 proper U12(X1, X2) -> U12(proper X1, proper X2),
                             proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                         proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                        proper tt() -> ok tt(),
                                proper pair(X1, X2) -> pair(proper X1, proper X2),
                                proper cons(X1, X2) -> cons(proper X1, proper X2),
                                       proper snd X -> snd proper X,
                            proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                                 proper and(X1, X2) -> and(proper X1, proper X2),
                                       proper fst X -> fst proper X,
                                      proper head X -> head proper X,
                                  proper natsFrom X -> natsFrom proper X,
                                         proper s X -> s proper X,
                                 proper sel(X1, X2) -> sel(proper X1, proper X2),
                                       proper nil() -> ok nil(),
                                         proper 0() -> ok 0(),
                                      proper tail X -> tail proper X,
                                proper take(X1, X2) -> take(proper X1, proper X2),
                                         top mark X -> top proper X,
                                           top ok X -> top active X}
                  POLY:
                   Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
                   Interpretation:
                    [U11](x0, x1, x2, x3) = x0 + 1,
                    
                    [U12](x0, x1) = x0 + 1,
                    
                    [splitAt](x0, x1) = x0 + x1 + 1,
                    
                    [pair](x0, x1) = x0 + 1,
                    
                    [cons](x0, x1) = 1,
                    
                    [afterNth](x0, x1) = x0 + 1,
                    
                    [and](x0, x1) = x0 + 1,
                    
                    [sel](x0, x1) = x0 + 1,
                    
                    [take](x0, x1) = x0 + x1 + 1,
                    
                    [mark](x0) = x0 + 1,
                    
                    [active](x0) = x0 + 1,
                    
                    [snd](x0) = x0 + 1,
                    
                    [fst](x0) = x0 + 1,
                    
                    [head](x0) = x0 + 1,
                    
                    [natsFrom](x0) = x0 + 1,
                    
                    [s](x0) = 1,
                    
                    [tail](x0) = x0 + 1,
                    
                    [proper](x0) = x0 + 1,
                    
                    [ok](x0) = x0 + 1,
                    
                    [top](x0) = 0,
                    
                    [tt] = 1,
                    
                    [nil] = 1,
                    
                    [0] = 0,
                    
                    [proper#](x0) = x0 + 1
                   Strict:
                    proper# splitAt(X1, X2) -> proper# X2
                    2 + 1X1 + 1X2 >= 1 + 1X2
                    proper# splitAt(X1, X2) -> proper# X1
                    2 + 1X1 + 1X2 >= 1 + 1X1
                   Weak:
                    top ok X -> top active X
                    0 + 0X >= 0 + 0X
                    top mark X -> top proper X
                    0 + 0X >= 0 + 0X
                    proper take(X1, X2) -> take(proper X1, proper X2)
                    2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
                    proper tail X -> tail proper X
                    2 + 1X >= 2 + 1X
                    proper 0() -> ok 0()
                    1 >= 1
                    proper nil() -> ok nil()
                    2 >= 2
                    proper sel(X1, X2) -> sel(proper X1, proper X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    proper s X -> s proper X
                    2 + 0X >= 1 + 0X
                    proper natsFrom X -> natsFrom proper X
                    2 + 1X >= 2 + 1X
                    proper head X -> head proper X
                    2 + 1X >= 2 + 1X
                    proper fst X -> fst proper X
                    2 + 1X >= 2 + 1X
                    proper and(X1, X2) -> and(proper X1, proper X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    proper snd X -> snd proper X
                    2 + 1X >= 2 + 1X
                    proper cons(X1, X2) -> cons(proper X1, proper X2)
                    2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                    proper pair(X1, X2) -> pair(proper X1, proper X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    proper tt() -> ok tt()
                    2 >= 2
                    proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
                    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
                    proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
                    2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
                    proper U12(X1, X2) -> U12(proper X1, proper X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    take(ok X1, ok X2) -> ok take(X1, X2)
                    3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    take(mark X1, X2) -> mark take(X1, X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    take(X1, mark X2) -> mark take(X1, X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    tail ok X -> ok tail X
                    2 + 1X >= 2 + 1X
                    tail mark X -> mark tail X
                    2 + 1X >= 2 + 1X
                    sel(ok X1, ok X2) -> ok sel(X1, X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    sel(mark X1, X2) -> mark sel(X1, X2)
                    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    sel(X1, mark X2) -> mark sel(X1, X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    s ok X -> ok s X
                    1 + 0X >= 2 + 0X
                    s mark X -> mark s X
                    1 + 0X >= 2 + 0X
                    natsFrom ok X -> ok natsFrom X
                    2 + 1X >= 2 + 1X
                    natsFrom mark X -> mark natsFrom X
                    2 + 1X >= 2 + 1X
                    head ok X -> ok head X
                    2 + 1X >= 2 + 1X
                    head mark X -> mark head X
                    2 + 1X >= 2 + 1X
                    fst ok X -> ok fst X
                    2 + 1X >= 2 + 1X
                    fst mark X -> mark fst X
                    2 + 1X >= 2 + 1X
                    and(ok X1, ok X2) -> ok and(X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    and(mark X1, X2) -> mark and(X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    afterNth(mark X1, X2) -> mark afterNth(X1, X2)
                    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    afterNth(X1, mark X2) -> mark afterNth(X1, X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    snd ok X -> ok snd X
                    2 + 1X >= 2 + 1X
                    snd mark X -> mark snd X
                    2 + 1X >= 2 + 1X
                    cons(ok X1, ok X2) -> ok cons(X1, X2)
                    1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                    cons(mark X1, X2) -> mark cons(X1, X2)
                    1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                    pair(ok X1, ok X2) -> ok pair(X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    pair(mark X1, X2) -> mark pair(X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    pair(X1, mark X2) -> mark pair(X1, X2)
                    1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
                    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
                    U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
                    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
                    active take(X1, X2) -> take(active X1, X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    active take(X1, X2) -> take(X1, active X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    active take(N, XS) -> mark fst splitAt(N, XS)
                    2 + 1N + 1XS >= 3 + 1N + 1XS
                    active tail cons(N, XS) -> mark XS
                    3 + 0N + 0XS >= 1 + 1XS
                    active tail X -> tail active X
                    2 + 1X >= 2 + 1X
                    active sel(X1, X2) -> sel(active X1, X2)
                    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                    active sel(X1, X2) -> sel(X1, active X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    active sel(N, XS) -> mark head afterNth(N, XS)
                    2 + 0N + 1XS >= 3 + 0N + 1XS
                    active s X -> s active X
                    2 + 0X >= 1 + 0X
                    active natsFrom X -> natsFrom active X
                    2 + 1X >= 2 + 1X
                    active natsFrom N -> mark cons(N, natsFrom s N)
                    2 + 1N >= 2 + 0N
                    active head cons(N, XS) -> mark N
                    3 + 0N + 0XS >= 1 + 1N
                    active head X -> head active X
                    2 + 1X >= 2 + 1X
                    active fst pair(X, Y) -> mark X
                    3 + 1X + 0Y >= 1 + 1X
                    active fst X -> fst active X
                    2 + 1X >= 2 + 1X
                    active and(tt(), X) -> mark X
                    3 + 0X >= 1 + 1X
                    active and(X1, X2) -> and(active X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    active afterNth(X1, X2) -> afterNth(active X1, X2)
                    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                    active afterNth(X1, X2) -> afterNth(X1, active X2)
                    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                    active afterNth(N, XS) -> mark snd splitAt(N, XS)
                    2 + 0N + 1XS >= 3 + 1N + 1XS
                    active snd pair(X, Y) -> mark Y
                    3 + 1X + 0Y >= 1 + 1Y
                    active snd X -> snd active X
                    2 + 1X >= 2 + 1X
                    active cons(X1, X2) -> cons(active X1, X2)
                    2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                    active pair(X1, X2) -> pair(active X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    active pair(X1, X2) -> pair(X1, active X2)
                    2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
                    active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
                    3 + 0N + 0XS + 0X >= 3 + 1N + 1XS + 0X
                    active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
                    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
                    active splitAt(0(), XS) -> mark pair(nil(), XS)
                    2 + 1XS >= 3 + 0XS
                    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
                    4 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
                    active splitAt(X1, X2) -> splitAt(active X1, X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    active splitAt(X1, X2) -> splitAt(X1, active X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
                    3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
                    active U12(X1, X2) -> U12(active X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
                    3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    splitAt(mark X1, X2) -> mark splitAt(X1, X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    splitAt(X1, mark X2) -> mark splitAt(X1, X2)
                    2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                    U12(ok X1, ok X2) -> ok U12(X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                    U12(mark X1, X2) -> mark U12(X1, X2)
                    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                  Qed
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      SCC (20):
       Strict:
        {        active# U12(X1, X2) -> active# X1,
             active# splitAt(X1, X2) -> active# X1,
             active# splitAt(X1, X2) -> active# X2,
         active# U11(X1, X2, X3, X4) -> active# X1,
                active# pair(X1, X2) -> active# X1,
                active# pair(X1, X2) -> active# X2,
                active# cons(X1, X2) -> active# X1,
                       active# snd X -> active# X,
            active# afterNth(X1, X2) -> active# X1,
            active# afterNth(X1, X2) -> active# X2,
                 active# and(X1, X2) -> active# X1,
                       active# fst X -> active# X,
                      active# head X -> active# X,
                  active# natsFrom X -> active# X,
                         active# s X -> active# X,
                 active# sel(X1, X2) -> active# X1,
                 active# sel(X1, X2) -> active# X2,
                      active# tail X -> active# X,
                active# take(X1, X2) -> active# X1,
                active# take(X1, X2) -> active# X2}
       Weak:
       {                U12(mark X1, X2) -> mark U12(X1, X2),
                       U12(ok X1, ok X2) -> ok U12(X1, X2),
                    splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                    splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                      active U12(X1, X2) -> U12(active X1, X2),
             active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                  active splitAt(X1, X2) -> splitAt(X1, active X2),
                  active splitAt(X1, X2) -> splitAt(active X1, X2),
        active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                 active splitAt(0(), XS) -> mark pair(nil(), XS),
              active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
              active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                     active pair(X1, X2) -> pair(X1, active X2),
                     active pair(X1, X2) -> pair(active X1, X2),
                     active cons(X1, X2) -> cons(active X1, X2),
                            active snd X -> snd active X,
                   active snd pair(X, Y) -> mark Y,
                  active afterNth(N, XS) -> mark snd splitAt(N, XS),
                 active afterNth(X1, X2) -> afterNth(X1, active X2),
                 active afterNth(X1, X2) -> afterNth(active X1, X2),
                      active and(X1, X2) -> and(active X1, X2),
                     active and(tt(), X) -> mark X,
                            active fst X -> fst active X,
                   active fst pair(X, Y) -> mark X,
                           active head X -> head active X,
                 active head cons(N, XS) -> mark N,
                       active natsFrom N -> mark cons(N, natsFrom s N),
                       active natsFrom X -> natsFrom active X,
                              active s X -> s active X,
                       active sel(N, XS) -> mark head afterNth(N, XS),
                      active sel(X1, X2) -> sel(X1, active X2),
                      active sel(X1, X2) -> sel(active X1, X2),
                           active tail X -> tail active X,
                 active tail cons(N, XS) -> mark XS,
                      active take(N, XS) -> mark fst splitAt(N, XS),
                     active take(X1, X2) -> take(X1, active X2),
                     active take(X1, X2) -> take(active X1, X2),
                U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
         U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                       pair(X1, mark X2) -> mark pair(X1, X2),
                       pair(mark X1, X2) -> mark pair(X1, X2),
                      pair(ok X1, ok X2) -> ok pair(X1, X2),
                       cons(mark X1, X2) -> mark cons(X1, X2),
                      cons(ok X1, ok X2) -> ok cons(X1, X2),
                              snd mark X -> mark snd X,
                                snd ok X -> ok snd X,
                   afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                   afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                  afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                        and(mark X1, X2) -> mark and(X1, X2),
                       and(ok X1, ok X2) -> ok and(X1, X2),
                              fst mark X -> mark fst X,
                                fst ok X -> ok fst X,
                             head mark X -> mark head X,
                               head ok X -> ok head X,
                         natsFrom mark X -> mark natsFrom X,
                           natsFrom ok X -> ok natsFrom X,
                                s mark X -> mark s X,
                                  s ok X -> ok s X,
                        sel(X1, mark X2) -> mark sel(X1, X2),
                        sel(mark X1, X2) -> mark sel(X1, X2),
                       sel(ok X1, ok X2) -> ok sel(X1, X2),
                             tail mark X -> mark tail X,
                               tail ok X -> ok tail X,
                       take(X1, mark X2) -> mark take(X1, X2),
                       take(mark X1, X2) -> mark take(X1, X2),
                      take(ok X1, ok X2) -> ok take(X1, X2),
                      proper U12(X1, X2) -> U12(proper X1, proper X2),
                  proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
              proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                             proper tt() -> ok tt(),
                     proper pair(X1, X2) -> pair(proper X1, proper X2),
                     proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper snd X -> snd proper X,
                 proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                      proper and(X1, X2) -> and(proper X1, proper X2),
                            proper fst X -> fst proper X,
                           proper head X -> head proper X,
                       proper natsFrom X -> natsFrom proper X,
                              proper s X -> s proper X,
                      proper sel(X1, X2) -> sel(proper X1, proper X2),
                            proper nil() -> ok nil(),
                              proper 0() -> ok 0(),
                           proper tail X -> tail proper X,
                     proper take(X1, X2) -> take(proper X1, proper X2),
                              top mark X -> top proper X,
                                top ok X -> top active X}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [U11](x0, x1, x2, x3) = x0,
         
         [U12](x0, x1) = x0 + x1,
         
         [splitAt](x0, x1) = x0 + x1,
         
         [pair](x0, x1) = x0 + x1,
         
         [cons](x0, x1) = x0,
         
         [afterNth](x0, x1) = x0 + x1,
         
         [and](x0, x1) = x0 + x1,
         
         [sel](x0, x1) = x0 + x1,
         
         [take](x0, x1) = x0 + x1 + 1,
         
         [mark](x0) = x0,
         
         [active](x0) = 0,
         
         [snd](x0) = x0,
         
         [fst](x0) = x0,
         
         [head](x0) = x0,
         
         [natsFrom](x0) = x0,
         
         [s](x0) = x0,
         
         [tail](x0) = x0,
         
         [proper](x0) = x0 + 1,
         
         [ok](x0) = x0 + 1,
         
         [top](x0) = 0,
         
         [tt] = 0,
         
         [nil] = 0,
         
         [0] = 0,
         
         [active#](x0) = x0
        Strict:
         active# take(X1, X2) -> active# X2
         1 + 1X1 + 1X2 >= 0 + 1X2
         active# take(X1, X2) -> active# X1
         1 + 1X1 + 1X2 >= 0 + 1X1
         active# tail X -> active# X
         0 + 1X >= 0 + 1X
         active# sel(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# sel(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# s X -> active# X
         0 + 1X >= 0 + 1X
         active# natsFrom X -> active# X
         0 + 1X >= 0 + 1X
         active# head X -> active# X
         0 + 1X >= 0 + 1X
         active# fst X -> active# X
         0 + 1X >= 0 + 1X
         active# and(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# afterNth(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# afterNth(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# snd X -> active# X
         0 + 1X >= 0 + 1X
         active# cons(X1, X2) -> active# X1
         0 + 1X1 + 0X2 >= 0 + 1X1
         active# pair(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# pair(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# U11(X1, X2, X3, X4) -> active# X1
         0 + 1X1 + 0X2 + 0X3 + 0X4 >= 0 + 1X1
         active# splitAt(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# splitAt(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# U12(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
        Weak:
         top ok X -> top active X
         0 + 0X >= 0 + 0X
         top mark X -> top proper X
         0 + 0X >= 0 + 0X
         proper take(X1, X2) -> take(proper X1, proper X2)
         2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
         proper tail X -> tail proper X
         1 + 1X >= 1 + 1X
         proper 0() -> ok 0()
         1 >= 1
         proper nil() -> ok nil()
         1 >= 1
         proper sel(X1, X2) -> sel(proper X1, proper X2)
         1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         proper s X -> s proper X
         1 + 1X >= 1 + 1X
         proper natsFrom X -> natsFrom proper X
         1 + 1X >= 1 + 1X
         proper head X -> head proper X
         1 + 1X >= 1 + 1X
         proper fst X -> fst proper X
         1 + 1X >= 1 + 1X
         proper and(X1, X2) -> and(proper X1, proper X2)
         1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
         1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         proper snd X -> snd proper X
         1 + 1X >= 1 + 1X
         proper cons(X1, X2) -> cons(proper X1, proper X2)
         1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
         proper pair(X1, X2) -> pair(proper X1, proper X2)
         1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         proper tt() -> ok tt()
         1 >= 1
         proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
         1 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
         proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
         1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         proper U12(X1, X2) -> U12(proper X1, proper X2)
         1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         take(ok X1, ok X2) -> ok take(X1, X2)
         3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         take(mark X1, X2) -> mark take(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         take(X1, mark X2) -> mark take(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         tail ok X -> ok tail X
         1 + 1X >= 1 + 1X
         tail mark X -> mark tail X
         0 + 1X >= 0 + 1X
         sel(ok X1, ok X2) -> ok sel(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         sel(mark X1, X2) -> mark sel(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         sel(X1, mark X2) -> mark sel(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         s ok X -> ok s X
         1 + 1X >= 1 + 1X
         s mark X -> mark s X
         0 + 1X >= 0 + 1X
         natsFrom ok X -> ok natsFrom X
         1 + 1X >= 1 + 1X
         natsFrom mark X -> mark natsFrom X
         0 + 1X >= 0 + 1X
         head ok X -> ok head X
         1 + 1X >= 1 + 1X
         head mark X -> mark head X
         0 + 1X >= 0 + 1X
         fst ok X -> ok fst X
         1 + 1X >= 1 + 1X
         fst mark X -> mark fst X
         0 + 1X >= 0 + 1X
         and(ok X1, ok X2) -> ok and(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         and(mark X1, X2) -> mark and(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         afterNth(mark X1, X2) -> mark afterNth(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         afterNth(X1, mark X2) -> mark afterNth(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         snd ok X -> ok snd X
         1 + 1X >= 1 + 1X
         snd mark X -> mark snd X
         0 + 1X >= 0 + 1X
         cons(ok X1, ok X2) -> ok cons(X1, X2)
         1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
         cons(mark X1, X2) -> mark cons(X1, X2)
         0 + 1X1 + 0X2 >= 0 + 1X1 + 0X2
         pair(ok X1, ok X2) -> ok pair(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         pair(mark X1, X2) -> mark pair(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         pair(X1, mark X2) -> mark pair(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
         1 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
         U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
         0 + 1X1 + 0X2 + 0X3 + 0X4 >= 0 + 1X1 + 0X2 + 0X3 + 0X4
         active take(X1, X2) -> take(active X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
         active take(X1, X2) -> take(X1, active X2)
         0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
         active take(N, XS) -> mark fst splitAt(N, XS)
         0 + 0N + 0XS >= 0 + 1N + 1XS
         active tail cons(N, XS) -> mark XS
         0 + 0N + 0XS >= 0 + 1XS
         active tail X -> tail active X
         0 + 0X >= 0 + 0X
         active sel(X1, X2) -> sel(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active sel(X1, X2) -> sel(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active sel(N, XS) -> mark head afterNth(N, XS)
         0 + 0N + 0XS >= 0 + 1N + 1XS
         active s X -> s active X
         0 + 0X >= 0 + 0X
         active natsFrom X -> natsFrom active X
         0 + 0X >= 0 + 0X
         active natsFrom N -> mark cons(N, natsFrom s N)
         0 + 0N >= 0 + 1N
         active head cons(N, XS) -> mark N
         0 + 0N + 0XS >= 0 + 1N
         active head X -> head active X
         0 + 0X >= 0 + 0X
         active fst pair(X, Y) -> mark X
         0 + 0X + 0Y >= 0 + 1X
         active fst X -> fst active X
         0 + 0X >= 0 + 0X
         active and(tt(), X) -> mark X
         0 + 0X >= 0 + 1X
         active and(X1, X2) -> and(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active afterNth(X1, X2) -> afterNth(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active afterNth(X1, X2) -> afterNth(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active afterNth(N, XS) -> mark snd splitAt(N, XS)
         0 + 0N + 0XS >= 0 + 1N + 1XS
         active snd pair(X, Y) -> mark Y
         0 + 0X + 0Y >= 0 + 1Y
         active snd X -> snd active X
         0 + 0X >= 0 + 0X
         active cons(X1, X2) -> cons(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         active pair(X1, X2) -> pair(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active pair(X1, X2) -> pair(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
         0 + 0N + 0XS + 0X >= 0 + 1N + 1XS + 1X
         active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
         0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
         active splitAt(0(), XS) -> mark pair(nil(), XS)
         0 + 0XS >= 0 + 1XS
         active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
         0 + 0N + 0XS + 0X >= 0 + 0N + 0XS + 0X
         active splitAt(X1, X2) -> splitAt(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active splitAt(X1, X2) -> splitAt(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
         0 + 0X + 0YS + 0ZS >= 0 + 1X + 0YS + 1ZS
         active U12(X1, X2) -> U12(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         splitAt(mark X1, X2) -> mark splitAt(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         splitAt(X1, mark X2) -> mark splitAt(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         U12(ok X1, ok X2) -> ok U12(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         U12(mark X1, X2) -> mark U12(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
       SCCS (1):
        Scc:
         {        active# U12(X1, X2) -> active# X1,
              active# splitAt(X1, X2) -> active# X1,
              active# splitAt(X1, X2) -> active# X2,
          active# U11(X1, X2, X3, X4) -> active# X1,
                 active# pair(X1, X2) -> active# X1,
                 active# pair(X1, X2) -> active# X2,
                 active# cons(X1, X2) -> active# X1,
                        active# snd X -> active# X,
             active# afterNth(X1, X2) -> active# X1,
             active# afterNth(X1, X2) -> active# X2,
                  active# and(X1, X2) -> active# X1,
                        active# fst X -> active# X,
                       active# head X -> active# X,
                   active# natsFrom X -> active# X,
                          active# s X -> active# X,
                  active# sel(X1, X2) -> active# X1,
                  active# sel(X1, X2) -> active# X2,
                       active# tail X -> active# X}
        
        SCC (18):
         Strict:
          {        active# U12(X1, X2) -> active# X1,
               active# splitAt(X1, X2) -> active# X1,
               active# splitAt(X1, X2) -> active# X2,
           active# U11(X1, X2, X3, X4) -> active# X1,
                  active# pair(X1, X2) -> active# X1,
                  active# pair(X1, X2) -> active# X2,
                  active# cons(X1, X2) -> active# X1,
                         active# snd X -> active# X,
              active# afterNth(X1, X2) -> active# X1,
              active# afterNth(X1, X2) -> active# X2,
                   active# and(X1, X2) -> active# X1,
                         active# fst X -> active# X,
                        active# head X -> active# X,
                    active# natsFrom X -> active# X,
                           active# s X -> active# X,
                   active# sel(X1, X2) -> active# X1,
                   active# sel(X1, X2) -> active# X2,
                        active# tail X -> active# X}
         Weak:
         {                U12(mark X1, X2) -> mark U12(X1, X2),
                         U12(ok X1, ok X2) -> ok U12(X1, X2),
                      splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                      splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                        active U12(X1, X2) -> U12(active X1, X2),
               active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                    active splitAt(X1, X2) -> splitAt(X1, active X2),
                    active splitAt(X1, X2) -> splitAt(active X1, X2),
          active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                   active splitAt(0(), XS) -> mark pair(nil(), XS),
                active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                       active pair(X1, X2) -> pair(X1, active X2),
                       active pair(X1, X2) -> pair(active X1, X2),
                       active cons(X1, X2) -> cons(active X1, X2),
                              active snd X -> snd active X,
                     active snd pair(X, Y) -> mark Y,
                    active afterNth(N, XS) -> mark snd splitAt(N, XS),
                   active afterNth(X1, X2) -> afterNth(X1, active X2),
                   active afterNth(X1, X2) -> afterNth(active X1, X2),
                        active and(X1, X2) -> and(active X1, X2),
                       active and(tt(), X) -> mark X,
                              active fst X -> fst active X,
                     active fst pair(X, Y) -> mark X,
                             active head X -> head active X,
                   active head cons(N, XS) -> mark N,
                         active natsFrom N -> mark cons(N, natsFrom s N),
                         active natsFrom X -> natsFrom active X,
                                active s X -> s active X,
                         active sel(N, XS) -> mark head afterNth(N, XS),
                        active sel(X1, X2) -> sel(X1, active X2),
                        active sel(X1, X2) -> sel(active X1, X2),
                             active tail X -> tail active X,
                   active tail cons(N, XS) -> mark XS,
                        active take(N, XS) -> mark fst splitAt(N, XS),
                       active take(X1, X2) -> take(X1, active X2),
                       active take(X1, X2) -> take(active X1, X2),
                  U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
           U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                         pair(X1, mark X2) -> mark pair(X1, X2),
                         pair(mark X1, X2) -> mark pair(X1, X2),
                        pair(ok X1, ok X2) -> ok pair(X1, X2),
                         cons(mark X1, X2) -> mark cons(X1, X2),
                        cons(ok X1, ok X2) -> ok cons(X1, X2),
                                snd mark X -> mark snd X,
                                  snd ok X -> ok snd X,
                     afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                     afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                    afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                          and(mark X1, X2) -> mark and(X1, X2),
                         and(ok X1, ok X2) -> ok and(X1, X2),
                                fst mark X -> mark fst X,
                                  fst ok X -> ok fst X,
                               head mark X -> mark head X,
                                 head ok X -> ok head X,
                           natsFrom mark X -> mark natsFrom X,
                             natsFrom ok X -> ok natsFrom X,
                                  s mark X -> mark s X,
                                    s ok X -> ok s X,
                          sel(X1, mark X2) -> mark sel(X1, X2),
                          sel(mark X1, X2) -> mark sel(X1, X2),
                         sel(ok X1, ok X2) -> ok sel(X1, X2),
                               tail mark X -> mark tail X,
                                 tail ok X -> ok tail X,
                         take(X1, mark X2) -> mark take(X1, X2),
                         take(mark X1, X2) -> mark take(X1, X2),
                        take(ok X1, ok X2) -> ok take(X1, X2),
                        proper U12(X1, X2) -> U12(proper X1, proper X2),
                    proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                               proper tt() -> ok tt(),
                       proper pair(X1, X2) -> pair(proper X1, proper X2),
                       proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper snd X -> snd proper X,
                   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                        proper and(X1, X2) -> and(proper X1, proper X2),
                              proper fst X -> fst proper X,
                             proper head X -> head proper X,
                         proper natsFrom X -> natsFrom proper X,
                                proper s X -> s proper X,
                        proper sel(X1, X2) -> sel(proper X1, proper X2),
                              proper nil() -> ok nil(),
                                proper 0() -> ok 0(),
                             proper tail X -> tail proper X,
                       proper take(X1, X2) -> take(proper X1, proper X2),
                                top mark X -> top proper X,
                                  top ok X -> top active X}
         POLY:
          Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
          Interpretation:
           [U11](x0, x1, x2, x3) = x0,
           
           [U12](x0, x1) = x0 + x1,
           
           [splitAt](x0, x1) = x0 + x1,
           
           [pair](x0, x1) = x0 + x1,
           
           [cons](x0, x1) = x0,
           
           [afterNth](x0, x1) = x0 + x1,
           
           [and](x0, x1) = x0,
           
           [sel](x0, x1) = x0 + x1,
           
           [take](x0, x1) = x0 + 1,
           
           [mark](x0) = x0 + 1,
           
           [active](x0) = 0,
           
           [snd](x0) = x0,
           
           [fst](x0) = x0,
           
           [head](x0) = x0,
           
           [natsFrom](x0) = x0,
           
           [s](x0) = x0,
           
           [tail](x0) = x0 + 1,
           
           [proper](x0) = 0,
           
           [ok](x0) = x0 + 1,
           
           [top](x0) = 0,
           
           [tt] = 0,
           
           [nil] = 0,
           
           [0] = 0,
           
           [active#](x0) = x0
          Strict:
           active# tail X -> active# X
           1 + 1X >= 0 + 1X
           active# sel(X1, X2) -> active# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           active# sel(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
           active# s X -> active# X
           0 + 1X >= 0 + 1X
           active# natsFrom X -> active# X
           0 + 1X >= 0 + 1X
           active# head X -> active# X
           0 + 1X >= 0 + 1X
           active# fst X -> active# X
           0 + 1X >= 0 + 1X
           active# and(X1, X2) -> active# X1
           0 + 1X1 + 0X2 >= 0 + 1X1
           active# afterNth(X1, X2) -> active# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           active# afterNth(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
           active# snd X -> active# X
           0 + 1X >= 0 + 1X
           active# cons(X1, X2) -> active# X1
           0 + 1X1 + 0X2 >= 0 + 1X1
           active# pair(X1, X2) -> active# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           active# pair(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
           active# U11(X1, X2, X3, X4) -> active# X1
           0 + 1X1 + 0X2 + 0X3 + 0X4 >= 0 + 1X1
           active# splitAt(X1, X2) -> active# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           active# splitAt(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
           active# U12(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
          Weak:
           top ok X -> top active X
           0 + 0X >= 0 + 0X
           top mark X -> top proper X
           0 + 0X >= 0 + 0X
           proper take(X1, X2) -> take(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper tail X -> tail proper X
           0 + 0X >= 1 + 0X
           proper 0() -> ok 0()
           0 >= 1
           proper nil() -> ok nil()
           0 >= 1
           proper sel(X1, X2) -> sel(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper s X -> s proper X
           0 + 0X >= 0 + 0X
           proper natsFrom X -> natsFrom proper X
           0 + 0X >= 0 + 0X
           proper head X -> head proper X
           0 + 0X >= 0 + 0X
           proper fst X -> fst proper X
           0 + 0X >= 0 + 0X
           proper and(X1, X2) -> and(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper snd X -> snd proper X
           0 + 0X >= 0 + 0X
           proper cons(X1, X2) -> cons(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper pair(X1, X2) -> pair(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper tt() -> ok tt()
           0 >= 1
           proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
           0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
           proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper U12(X1, X2) -> U12(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           take(ok X1, ok X2) -> ok take(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           take(mark X1, X2) -> mark take(X1, X2)
           1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           take(X1, mark X2) -> mark take(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           tail ok X -> ok tail X
           2 + 1X >= 2 + 1X
           tail mark X -> mark tail X
           2 + 1X >= 2 + 1X
           sel(ok X1, ok X2) -> ok sel(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           sel(mark X1, X2) -> mark sel(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           sel(X1, mark X2) -> mark sel(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           s ok X -> ok s X
           1 + 1X >= 1 + 1X
           s mark X -> mark s X
           1 + 1X >= 1 + 1X
           natsFrom ok X -> ok natsFrom X
           1 + 1X >= 1 + 1X
           natsFrom mark X -> mark natsFrom X
           1 + 1X >= 1 + 1X
           head ok X -> ok head X
           1 + 1X >= 1 + 1X
           head mark X -> mark head X
           1 + 1X >= 1 + 1X
           fst ok X -> ok fst X
           1 + 1X >= 1 + 1X
           fst mark X -> mark fst X
           1 + 1X >= 1 + 1X
           and(ok X1, ok X2) -> ok and(X1, X2)
           1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
           and(mark X1, X2) -> mark and(X1, X2)
           1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
           afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           afterNth(mark X1, X2) -> mark afterNth(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           afterNth(X1, mark X2) -> mark afterNth(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           snd ok X -> ok snd X
           1 + 1X >= 1 + 1X
           snd mark X -> mark snd X
           1 + 1X >= 1 + 1X
           cons(ok X1, ok X2) -> ok cons(X1, X2)
           1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
           cons(mark X1, X2) -> mark cons(X1, X2)
           1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
           pair(ok X1, ok X2) -> ok pair(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           pair(mark X1, X2) -> mark pair(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           pair(X1, mark X2) -> mark pair(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
           1 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
           U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
           1 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
           active take(X1, X2) -> take(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
           active take(X1, X2) -> take(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           active take(N, XS) -> mark fst splitAt(N, XS)
           0 + 0N + 0XS >= 1 + 1N + 1XS
           active tail cons(N, XS) -> mark XS
           0 + 0N + 0XS >= 1 + 1XS
           active tail X -> tail active X
           0 + 0X >= 1 + 0X
           active sel(X1, X2) -> sel(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           active sel(X1, X2) -> sel(X1, active X2)
           0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
           active sel(N, XS) -> mark head afterNth(N, XS)
           0 + 0N + 0XS >= 1 + 1N + 1XS
           active s X -> s active X
           0 + 0X >= 0 + 0X
           active natsFrom X -> natsFrom active X
           0 + 0X >= 0 + 0X
           active natsFrom N -> mark cons(N, natsFrom s N)
           0 + 0N >= 1 + 1N
           active head cons(N, XS) -> mark N
           0 + 0N + 0XS >= 1 + 1N
           active head X -> head active X
           0 + 0X >= 0 + 0X
           active fst pair(X, Y) -> mark X
           0 + 0X + 0Y >= 1 + 1X
           active fst X -> fst active X
           0 + 0X >= 0 + 0X
           active and(tt(), X) -> mark X
           0 + 0X >= 1 + 1X
           active and(X1, X2) -> and(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           active afterNth(X1, X2) -> afterNth(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           active afterNth(X1, X2) -> afterNth(X1, active X2)
           0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
           active afterNth(N, XS) -> mark snd splitAt(N, XS)
           0 + 0N + 0XS >= 1 + 1N + 1XS
           active snd pair(X, Y) -> mark Y
           0 + 0X + 0Y >= 1 + 1Y
           active snd X -> snd active X
           0 + 0X >= 0 + 0X
           active cons(X1, X2) -> cons(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           active pair(X1, X2) -> pair(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           active pair(X1, X2) -> pair(X1, active X2)
           0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
           active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
           0 + 0N + 0XS + 0X >= 1 + 1N + 1XS + 1X
           active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
           0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
           active splitAt(0(), XS) -> mark pair(nil(), XS)
           0 + 0XS >= 1 + 1XS
           active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
           0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
           active splitAt(X1, X2) -> splitAt(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           active splitAt(X1, X2) -> splitAt(X1, active X2)
           0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
           active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
           0 + 0X + 0YS + 0ZS >= 1 + 1X + 0YS + 1ZS
           active U12(X1, X2) -> U12(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           splitAt(mark X1, X2) -> mark splitAt(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           splitAt(X1, mark X2) -> mark splitAt(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           U12(ok X1, ok X2) -> ok U12(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           U12(mark X1, X2) -> mark U12(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         SCCS (1):
          Scc:
           {        active# U12(X1, X2) -> active# X1,
                active# splitAt(X1, X2) -> active# X1,
                active# splitAt(X1, X2) -> active# X2,
            active# U11(X1, X2, X3, X4) -> active# X1,
                   active# pair(X1, X2) -> active# X1,
                   active# pair(X1, X2) -> active# X2,
                   active# cons(X1, X2) -> active# X1,
                          active# snd X -> active# X,
               active# afterNth(X1, X2) -> active# X1,
               active# afterNth(X1, X2) -> active# X2,
                    active# and(X1, X2) -> active# X1,
                          active# fst X -> active# X,
                         active# head X -> active# X,
                     active# natsFrom X -> active# X,
                            active# s X -> active# X,
                    active# sel(X1, X2) -> active# X1,
                    active# sel(X1, X2) -> active# X2}
          
          SCC (17):
           Strict:
            {        active# U12(X1, X2) -> active# X1,
                 active# splitAt(X1, X2) -> active# X1,
                 active# splitAt(X1, X2) -> active# X2,
             active# U11(X1, X2, X3, X4) -> active# X1,
                    active# pair(X1, X2) -> active# X1,
                    active# pair(X1, X2) -> active# X2,
                    active# cons(X1, X2) -> active# X1,
                           active# snd X -> active# X,
                active# afterNth(X1, X2) -> active# X1,
                active# afterNth(X1, X2) -> active# X2,
                     active# and(X1, X2) -> active# X1,
                           active# fst X -> active# X,
                          active# head X -> active# X,
                      active# natsFrom X -> active# X,
                             active# s X -> active# X,
                     active# sel(X1, X2) -> active# X1,
                     active# sel(X1, X2) -> active# X2}
           Weak:
           {                U12(mark X1, X2) -> mark U12(X1, X2),
                           U12(ok X1, ok X2) -> ok U12(X1, X2),
                        splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                        splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                       splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                          active U12(X1, X2) -> U12(active X1, X2),
                 active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                      active splitAt(X1, X2) -> splitAt(X1, active X2),
                      active splitAt(X1, X2) -> splitAt(active X1, X2),
            active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                     active splitAt(0(), XS) -> mark pair(nil(), XS),
                  active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                  active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                         active pair(X1, X2) -> pair(X1, active X2),
                         active pair(X1, X2) -> pair(active X1, X2),
                         active cons(X1, X2) -> cons(active X1, X2),
                                active snd X -> snd active X,
                       active snd pair(X, Y) -> mark Y,
                      active afterNth(N, XS) -> mark snd splitAt(N, XS),
                     active afterNth(X1, X2) -> afterNth(X1, active X2),
                     active afterNth(X1, X2) -> afterNth(active X1, X2),
                          active and(X1, X2) -> and(active X1, X2),
                         active and(tt(), X) -> mark X,
                                active fst X -> fst active X,
                       active fst pair(X, Y) -> mark X,
                               active head X -> head active X,
                     active head cons(N, XS) -> mark N,
                           active natsFrom N -> mark cons(N, natsFrom s N),
                           active natsFrom X -> natsFrom active X,
                                  active s X -> s active X,
                           active sel(N, XS) -> mark head afterNth(N, XS),
                          active sel(X1, X2) -> sel(X1, active X2),
                          active sel(X1, X2) -> sel(active X1, X2),
                               active tail X -> tail active X,
                     active tail cons(N, XS) -> mark XS,
                          active take(N, XS) -> mark fst splitAt(N, XS),
                         active take(X1, X2) -> take(X1, active X2),
                         active take(X1, X2) -> take(active X1, X2),
                    U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
             U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                           pair(X1, mark X2) -> mark pair(X1, X2),
                           pair(mark X1, X2) -> mark pair(X1, X2),
                          pair(ok X1, ok X2) -> ok pair(X1, X2),
                           cons(mark X1, X2) -> mark cons(X1, X2),
                          cons(ok X1, ok X2) -> ok cons(X1, X2),
                                  snd mark X -> mark snd X,
                                    snd ok X -> ok snd X,
                       afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                       afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                      afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                            and(mark X1, X2) -> mark and(X1, X2),
                           and(ok X1, ok X2) -> ok and(X1, X2),
                                  fst mark X -> mark fst X,
                                    fst ok X -> ok fst X,
                                 head mark X -> mark head X,
                                   head ok X -> ok head X,
                             natsFrom mark X -> mark natsFrom X,
                               natsFrom ok X -> ok natsFrom X,
                                    s mark X -> mark s X,
                                      s ok X -> ok s X,
                            sel(X1, mark X2) -> mark sel(X1, X2),
                            sel(mark X1, X2) -> mark sel(X1, X2),
                           sel(ok X1, ok X2) -> ok sel(X1, X2),
                                 tail mark X -> mark tail X,
                                   tail ok X -> ok tail X,
                           take(X1, mark X2) -> mark take(X1, X2),
                           take(mark X1, X2) -> mark take(X1, X2),
                          take(ok X1, ok X2) -> ok take(X1, X2),
                          proper U12(X1, X2) -> U12(proper X1, proper X2),
                      proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                  proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                 proper tt() -> ok tt(),
                         proper pair(X1, X2) -> pair(proper X1, proper X2),
                         proper cons(X1, X2) -> cons(proper X1, proper X2),
                                proper snd X -> snd proper X,
                     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                          proper and(X1, X2) -> and(proper X1, proper X2),
                                proper fst X -> fst proper X,
                               proper head X -> head proper X,
                           proper natsFrom X -> natsFrom proper X,
                                  proper s X -> s proper X,
                          proper sel(X1, X2) -> sel(proper X1, proper X2),
                                proper nil() -> ok nil(),
                                  proper 0() -> ok 0(),
                               proper tail X -> tail proper X,
                         proper take(X1, X2) -> take(proper X1, proper X2),
                                  top mark X -> top proper X,
                                    top ok X -> top active X}
           POLY:
            Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
            Interpretation:
             [U11](x0, x1, x2, x3) = x0,
             
             [U12](x0, x1) = x0 + x1,
             
             [splitAt](x0, x1) = x0 + x1,
             
             [pair](x0, x1) = x0 + x1,
             
             [cons](x0, x1) = x0,
             
             [afterNth](x0, x1) = x0 + x1,
             
             [and](x0, x1) = x0,
             
             [sel](x0, x1) = x0 + x1 + 1,
             
             [take](x0, x1) = x0 + 1,
             
             [mark](x0) = x0 + 1,
             
             [active](x0) = 0,
             
             [snd](x0) = x0,
             
             [fst](x0) = x0,
             
             [head](x0) = x0,
             
             [natsFrom](x0) = x0,
             
             [s](x0) = x0,
             
             [tail](x0) = 0,
             
             [proper](x0) = 0,
             
             [ok](x0) = x0 + 1,
             
             [top](x0) = 0,
             
             [tt] = 0,
             
             [nil] = 0,
             
             [0] = 0,
             
             [active#](x0) = x0
            Strict:
             active# sel(X1, X2) -> active# X2
             1 + 1X1 + 1X2 >= 0 + 1X2
             active# sel(X1, X2) -> active# X1
             1 + 1X1 + 1X2 >= 0 + 1X1
             active# s X -> active# X
             0 + 1X >= 0 + 1X
             active# natsFrom X -> active# X
             0 + 1X >= 0 + 1X
             active# head X -> active# X
             0 + 1X >= 0 + 1X
             active# fst X -> active# X
             0 + 1X >= 0 + 1X
             active# and(X1, X2) -> active# X1
             0 + 1X1 + 0X2 >= 0 + 1X1
             active# afterNth(X1, X2) -> active# X2
             0 + 1X1 + 1X2 >= 0 + 1X2
             active# afterNth(X1, X2) -> active# X1
             0 + 1X1 + 1X2 >= 0 + 1X1
             active# snd X -> active# X
             0 + 1X >= 0 + 1X
             active# cons(X1, X2) -> active# X1
             0 + 1X1 + 0X2 >= 0 + 1X1
             active# pair(X1, X2) -> active# X2
             0 + 1X1 + 1X2 >= 0 + 1X2
             active# pair(X1, X2) -> active# X1
             0 + 1X1 + 1X2 >= 0 + 1X1
             active# U11(X1, X2, X3, X4) -> active# X1
             0 + 1X1 + 0X2 + 0X3 + 0X4 >= 0 + 1X1
             active# splitAt(X1, X2) -> active# X2
             0 + 1X1 + 1X2 >= 0 + 1X2
             active# splitAt(X1, X2) -> active# X1
             0 + 1X1 + 1X2 >= 0 + 1X1
             active# U12(X1, X2) -> active# X1
             0 + 1X1 + 1X2 >= 0 + 1X1
            Weak:
             top ok X -> top active X
             0 + 0X >= 0 + 0X
             top mark X -> top proper X
             0 + 0X >= 0 + 0X
             proper take(X1, X2) -> take(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             proper tail X -> tail proper X
             0 + 0X >= 0 + 0X
             proper 0() -> ok 0()
             0 >= 1
             proper nil() -> ok nil()
             0 >= 1
             proper sel(X1, X2) -> sel(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             proper s X -> s proper X
             0 + 0X >= 0 + 0X
             proper natsFrom X -> natsFrom proper X
             0 + 0X >= 0 + 0X
             proper head X -> head proper X
             0 + 0X >= 0 + 0X
             proper fst X -> fst proper X
             0 + 0X >= 0 + 0X
             proper and(X1, X2) -> and(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper snd X -> snd proper X
             0 + 0X >= 0 + 0X
             proper cons(X1, X2) -> cons(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper pair(X1, X2) -> pair(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper tt() -> ok tt()
             0 >= 1
             proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
             0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
             proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper U12(X1, X2) -> U12(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             take(ok X1, ok X2) -> ok take(X1, X2)
             2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
             take(mark X1, X2) -> mark take(X1, X2)
             1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
             take(X1, mark X2) -> mark take(X1, X2)
             2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
             tail ok X -> ok tail X
             0 + 0X >= 1 + 0X
             tail mark X -> mark tail X
             0 + 0X >= 1 + 0X
             sel(ok X1, ok X2) -> ok sel(X1, X2)
             3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             sel(mark X1, X2) -> mark sel(X1, X2)
             2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             sel(X1, mark X2) -> mark sel(X1, X2)
             2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             s ok X -> ok s X
             1 + 1X >= 1 + 1X
             s mark X -> mark s X
             1 + 1X >= 1 + 1X
             natsFrom ok X -> ok natsFrom X
             1 + 1X >= 1 + 1X
             natsFrom mark X -> mark natsFrom X
             1 + 1X >= 1 + 1X
             head ok X -> ok head X
             1 + 1X >= 1 + 1X
             head mark X -> mark head X
             1 + 1X >= 1 + 1X
             fst ok X -> ok fst X
             1 + 1X >= 1 + 1X
             fst mark X -> mark fst X
             1 + 1X >= 1 + 1X
             and(ok X1, ok X2) -> ok and(X1, X2)
             1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
             and(mark X1, X2) -> mark and(X1, X2)
             1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
             afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
             2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             afterNth(mark X1, X2) -> mark afterNth(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             afterNth(X1, mark X2) -> mark afterNth(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             snd ok X -> ok snd X
             1 + 1X >= 1 + 1X
             snd mark X -> mark snd X
             1 + 1X >= 1 + 1X
             cons(ok X1, ok X2) -> ok cons(X1, X2)
             1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
             cons(mark X1, X2) -> mark cons(X1, X2)
             1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
             pair(ok X1, ok X2) -> ok pair(X1, X2)
             2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             pair(mark X1, X2) -> mark pair(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             pair(X1, mark X2) -> mark pair(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
             1 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
             U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
             1 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
             active take(X1, X2) -> take(active X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
             active take(X1, X2) -> take(X1, active X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             active take(N, XS) -> mark fst splitAt(N, XS)
             0 + 0N + 0XS >= 1 + 1N + 1XS
             active tail cons(N, XS) -> mark XS
             0 + 0N + 0XS >= 1 + 1XS
             active tail X -> tail active X
             0 + 0X >= 0 + 0X
             active sel(X1, X2) -> sel(active X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
             active sel(X1, X2) -> sel(X1, active X2)
             0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
             active sel(N, XS) -> mark head afterNth(N, XS)
             0 + 0N + 0XS >= 1 + 1N + 1XS
             active s X -> s active X
             0 + 0X >= 0 + 0X
             active natsFrom X -> natsFrom active X
             0 + 0X >= 0 + 0X
             active natsFrom N -> mark cons(N, natsFrom s N)
             0 + 0N >= 1 + 1N
             active head cons(N, XS) -> mark N
             0 + 0N + 0XS >= 1 + 1N
             active head X -> head active X
             0 + 0X >= 0 + 0X
             active fst pair(X, Y) -> mark X
             0 + 0X + 0Y >= 1 + 1X
             active fst X -> fst active X
             0 + 0X >= 0 + 0X
             active and(tt(), X) -> mark X
             0 + 0X >= 1 + 1X
             active and(X1, X2) -> and(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             active afterNth(X1, X2) -> afterNth(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             active afterNth(X1, X2) -> afterNth(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
             active afterNth(N, XS) -> mark snd splitAt(N, XS)
             0 + 0N + 0XS >= 1 + 1N + 1XS
             active snd pair(X, Y) -> mark Y
             0 + 0X + 0Y >= 1 + 1Y
             active snd X -> snd active X
             0 + 0X >= 0 + 0X
             active cons(X1, X2) -> cons(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             active pair(X1, X2) -> pair(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             active pair(X1, X2) -> pair(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
             0 + 0N + 0XS + 0X >= 1 + 1N + 1XS + 1X
             active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
             0 + 0X1 + 0X2 + 0X3 + 0X4 >= 0 + 0X1 + 0X2 + 0X3 + 0X4
             active splitAt(0(), XS) -> mark pair(nil(), XS)
             0 + 0XS >= 1 + 1XS
             active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
             0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
             active splitAt(X1, X2) -> splitAt(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             active splitAt(X1, X2) -> splitAt(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
             active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
             0 + 0X + 0YS + 0ZS >= 1 + 1X + 0YS + 1ZS
             active U12(X1, X2) -> U12(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
             2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             splitAt(mark X1, X2) -> mark splitAt(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             splitAt(X1, mark X2) -> mark splitAt(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             U12(ok X1, ok X2) -> ok U12(X1, X2)
             2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             U12(mark X1, X2) -> mark U12(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           SCCS (1):
            Scc:
             {        active# U12(X1, X2) -> active# X1,
                  active# splitAt(X1, X2) -> active# X1,
                  active# splitAt(X1, X2) -> active# X2,
              active# U11(X1, X2, X3, X4) -> active# X1,
                     active# pair(X1, X2) -> active# X1,
                     active# pair(X1, X2) -> active# X2,
                     active# cons(X1, X2) -> active# X1,
                            active# snd X -> active# X,
                 active# afterNth(X1, X2) -> active# X1,
                 active# afterNth(X1, X2) -> active# X2,
                      active# and(X1, X2) -> active# X1,
                            active# fst X -> active# X,
                           active# head X -> active# X,
                       active# natsFrom X -> active# X,
                              active# s X -> active# X}
            
            SCC (15):
             Strict:
              {        active# U12(X1, X2) -> active# X1,
                   active# splitAt(X1, X2) -> active# X1,
                   active# splitAt(X1, X2) -> active# X2,
               active# U11(X1, X2, X3, X4) -> active# X1,
                      active# pair(X1, X2) -> active# X1,
                      active# pair(X1, X2) -> active# X2,
                      active# cons(X1, X2) -> active# X1,
                             active# snd X -> active# X,
                  active# afterNth(X1, X2) -> active# X1,
                  active# afterNth(X1, X2) -> active# X2,
                       active# and(X1, X2) -> active# X1,
                             active# fst X -> active# X,
                            active# head X -> active# X,
                        active# natsFrom X -> active# X,
                               active# s X -> active# X}
             Weak:
             {                U12(mark X1, X2) -> mark U12(X1, X2),
                             U12(ok X1, ok X2) -> ok U12(X1, X2),
                          splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                          splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                         splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                            active U12(X1, X2) -> U12(active X1, X2),
                   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                        active splitAt(X1, X2) -> splitAt(X1, active X2),
                        active splitAt(X1, X2) -> splitAt(active X1, X2),
              active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                       active splitAt(0(), XS) -> mark pair(nil(), XS),
                    active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
                    active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                           active pair(X1, X2) -> pair(X1, active X2),
                           active pair(X1, X2) -> pair(active X1, X2),
                           active cons(X1, X2) -> cons(active X1, X2),
                                  active snd X -> snd active X,
                         active snd pair(X, Y) -> mark Y,
                        active afterNth(N, XS) -> mark snd splitAt(N, XS),
                       active afterNth(X1, X2) -> afterNth(X1, active X2),
                       active afterNth(X1, X2) -> afterNth(active X1, X2),
                            active and(X1, X2) -> and(active X1, X2),
                           active and(tt(), X) -> mark X,
                                  active fst X -> fst active X,
                         active fst pair(X, Y) -> mark X,
                                 active head X -> head active X,
                       active head cons(N, XS) -> mark N,
                             active natsFrom N -> mark cons(N, natsFrom s N),
                             active natsFrom X -> natsFrom active X,
                                    active s X -> s active X,
                             active sel(N, XS) -> mark head afterNth(N, XS),
                            active sel(X1, X2) -> sel(X1, active X2),
                            active sel(X1, X2) -> sel(active X1, X2),
                                 active tail X -> tail active X,
                       active tail cons(N, XS) -> mark XS,
                            active take(N, XS) -> mark fst splitAt(N, XS),
                           active take(X1, X2) -> take(X1, active X2),
                           active take(X1, X2) -> take(active X1, X2),
                      U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
               U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                             pair(X1, mark X2) -> mark pair(X1, X2),
                             pair(mark X1, X2) -> mark pair(X1, X2),
                            pair(ok X1, ok X2) -> ok pair(X1, X2),
                             cons(mark X1, X2) -> mark cons(X1, X2),
                            cons(ok X1, ok X2) -> ok cons(X1, X2),
                                    snd mark X -> mark snd X,
                                      snd ok X -> ok snd X,
                         afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                         afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                        afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                              and(mark X1, X2) -> mark and(X1, X2),
                             and(ok X1, ok X2) -> ok and(X1, X2),
                                    fst mark X -> mark fst X,
                                      fst ok X -> ok fst X,
                                   head mark X -> mark head X,
                                     head ok X -> ok head X,
                               natsFrom mark X -> mark natsFrom X,
                                 natsFrom ok X -> ok natsFrom X,
                                      s mark X -> mark s X,
                                        s ok X -> ok s X,
                              sel(X1, mark X2) -> mark sel(X1, X2),
                              sel(mark X1, X2) -> mark sel(X1, X2),
                             sel(ok X1, ok X2) -> ok sel(X1, X2),
                                   tail mark X -> mark tail X,
                                     tail ok X -> ok tail X,
                             take(X1, mark X2) -> mark take(X1, X2),
                             take(mark X1, X2) -> mark take(X1, X2),
                            take(ok X1, ok X2) -> ok take(X1, X2),
                            proper U12(X1, X2) -> U12(proper X1, proper X2),
                        proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
                    proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                                   proper tt() -> ok tt(),
                           proper pair(X1, X2) -> pair(proper X1, proper X2),
                           proper cons(X1, X2) -> cons(proper X1, proper X2),
                                  proper snd X -> snd proper X,
                       proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                            proper and(X1, X2) -> and(proper X1, proper X2),
                                  proper fst X -> fst proper X,
                                 proper head X -> head proper X,
                             proper natsFrom X -> natsFrom proper X,
                                    proper s X -> s proper X,
                            proper sel(X1, X2) -> sel(proper X1, proper X2),
                                  proper nil() -> ok nil(),
                                    proper 0() -> ok 0(),
                                 proper tail X -> tail proper X,
                           proper take(X1, X2) -> take(proper X1, proper X2),
                                    top mark X -> top proper X,
                                      top ok X -> top active X}
             POLY:
              Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
              Interpretation:
               [U11](x0, x1, x2, x3) = x0 + 1,
               
               [U12](x0, x1) = x0 + 1,
               
               [splitAt](x0, x1) = x0 + x1 + 1,
               
               [pair](x0, x1) = x0 + x1 + 1,
               
               [cons](x0, x1) = x0 + 1,
               
               [afterNth](x0, x1) = x0 + x1 + 1,
               
               [and](x0, x1) = x0 + 1,
               
               [sel](x0, x1) = x0 + 1,
               
               [take](x0, x1) = x0 + 1,
               
               [mark](x0) = x0 + 1,
               
               [active](x0) = x0 + 1,
               
               [snd](x0) = x0 + 1,
               
               [fst](x0) = x0 + 1,
               
               [head](x0) = x0 + 1,
               
               [natsFrom](x0) = x0 + 1,
               
               [s](x0) = x0 + 1,
               
               [tail](x0) = x0 + 1,
               
               [proper](x0) = x0 + 1,
               
               [ok](x0) = x0 + 1,
               
               [top](x0) = 0,
               
               [tt] = 1,
               
               [nil] = 1,
               
               [0] = 0,
               
               [active#](x0) = x0 + 1
              Strict:
               active# s X -> active# X
               2 + 1X >= 1 + 1X
               active# natsFrom X -> active# X
               2 + 1X >= 1 + 1X
               active# head X -> active# X
               2 + 1X >= 1 + 1X
               active# fst X -> active# X
               2 + 1X >= 1 + 1X
               active# and(X1, X2) -> active# X1
               2 + 1X1 + 0X2 >= 1 + 1X1
               active# afterNth(X1, X2) -> active# X2
               2 + 1X1 + 1X2 >= 1 + 1X2
               active# afterNth(X1, X2) -> active# X1
               2 + 1X1 + 1X2 >= 1 + 1X1
               active# snd X -> active# X
               2 + 1X >= 1 + 1X
               active# cons(X1, X2) -> active# X1
               2 + 1X1 + 0X2 >= 1 + 1X1
               active# pair(X1, X2) -> active# X2
               2 + 1X1 + 1X2 >= 1 + 1X2
               active# pair(X1, X2) -> active# X1
               2 + 1X1 + 1X2 >= 1 + 1X1
               active# U11(X1, X2, X3, X4) -> active# X1
               2 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1
               active# splitAt(X1, X2) -> active# X2
               2 + 1X1 + 1X2 >= 1 + 1X2
               active# splitAt(X1, X2) -> active# X1
               2 + 1X1 + 1X2 >= 1 + 1X1
               active# U12(X1, X2) -> active# X1
               2 + 1X1 + 0X2 >= 1 + 1X1
              Weak:
               top ok X -> top active X
               0 + 0X >= 0 + 0X
               top mark X -> top proper X
               0 + 0X >= 0 + 0X
               proper take(X1, X2) -> take(proper X1, proper X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               proper tail X -> tail proper X
               2 + 1X >= 2 + 1X
               proper 0() -> ok 0()
               1 >= 1
               proper nil() -> ok nil()
               2 >= 2
               proper sel(X1, X2) -> sel(proper X1, proper X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               proper s X -> s proper X
               2 + 1X >= 2 + 1X
               proper natsFrom X -> natsFrom proper X
               2 + 1X >= 2 + 1X
               proper head X -> head proper X
               2 + 1X >= 2 + 1X
               proper fst X -> fst proper X
               2 + 1X >= 2 + 1X
               proper and(X1, X2) -> and(proper X1, proper X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
               2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
               proper snd X -> snd proper X
               2 + 1X >= 2 + 1X
               proper cons(X1, X2) -> cons(proper X1, proper X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               proper pair(X1, X2) -> pair(proper X1, proper X2)
               2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
               proper tt() -> ok tt()
               2 >= 2
               proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
               2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
               proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
               2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
               proper U12(X1, X2) -> U12(proper X1, proper X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               take(ok X1, ok X2) -> ok take(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               take(mark X1, X2) -> mark take(X1, X2)
               1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               take(X1, mark X2) -> mark take(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               tail ok X -> ok tail X
               2 + 1X >= 2 + 1X
               tail mark X -> mark tail X
               2 + 1X >= 2 + 1X
               sel(ok X1, ok X2) -> ok sel(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               sel(mark X1, X2) -> mark sel(X1, X2)
               1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               sel(X1, mark X2) -> mark sel(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               s ok X -> ok s X
               2 + 1X >= 2 + 1X
               s mark X -> mark s X
               2 + 1X >= 2 + 1X
               natsFrom ok X -> ok natsFrom X
               2 + 1X >= 2 + 1X
               natsFrom mark X -> mark natsFrom X
               2 + 1X >= 2 + 1X
               head ok X -> ok head X
               2 + 1X >= 2 + 1X
               head mark X -> mark head X
               2 + 1X >= 2 + 1X
               fst ok X -> ok fst X
               2 + 1X >= 2 + 1X
               fst mark X -> mark fst X
               2 + 1X >= 2 + 1X
               and(ok X1, ok X2) -> ok and(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               and(mark X1, X2) -> mark and(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
               3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               afterNth(mark X1, X2) -> mark afterNth(X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               afterNth(X1, mark X2) -> mark afterNth(X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               snd ok X -> ok snd X
               2 + 1X >= 2 + 1X
               snd mark X -> mark snd X
               2 + 1X >= 2 + 1X
               cons(ok X1, ok X2) -> ok cons(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               cons(mark X1, X2) -> mark cons(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               pair(ok X1, ok X2) -> ok pair(X1, X2)
               3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               pair(mark X1, X2) -> mark pair(X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               pair(X1, mark X2) -> mark pair(X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
               2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
               U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
               2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
               active take(X1, X2) -> take(active X1, X2)
               2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
               active take(X1, X2) -> take(X1, active X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               active take(N, XS) -> mark fst splitAt(N, XS)
               2 + 0N + 1XS >= 3 + 1N + 1XS
               active tail cons(N, XS) -> mark XS
               3 + 1N + 0XS >= 1 + 1XS
               active tail X -> tail active X
               2 + 1X >= 2 + 1X
               active sel(X1, X2) -> sel(active X1, X2)
               2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
               active sel(X1, X2) -> sel(X1, active X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               active sel(N, XS) -> mark head afterNth(N, XS)
               2 + 0N + 1XS >= 3 + 1N + 1XS
               active s X -> s active X
               2 + 1X >= 2 + 1X
               active natsFrom X -> natsFrom active X
               2 + 1X >= 2 + 1X
               active natsFrom N -> mark cons(N, natsFrom s N)
               2 + 1N >= 2 + 1N
               active head cons(N, XS) -> mark N
               3 + 1N + 0XS >= 1 + 1N
               active head X -> head active X
               2 + 1X >= 2 + 1X
               active fst pair(X, Y) -> mark X
               3 + 1X + 1Y >= 1 + 1X
               active fst X -> fst active X
               2 + 1X >= 2 + 1X
               active and(tt(), X) -> mark X
               3 + 0X >= 1 + 1X
               active and(X1, X2) -> and(active X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               active afterNth(X1, X2) -> afterNth(active X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               active afterNth(X1, X2) -> afterNth(X1, active X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               active afterNth(N, XS) -> mark snd splitAt(N, XS)
               2 + 1N + 1XS >= 3 + 1N + 1XS
               active snd pair(X, Y) -> mark Y
               3 + 1X + 1Y >= 1 + 1Y
               active snd X -> snd active X
               2 + 1X >= 2 + 1X
               active cons(X1, X2) -> cons(active X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               active pair(X1, X2) -> pair(active X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               active pair(X1, X2) -> pair(X1, active X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
               3 + 0N + 0XS + 0X >= 3 + 1N + 1XS + 0X
               active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
               2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
               active splitAt(0(), XS) -> mark pair(nil(), XS)
               2 + 1XS >= 3 + 1XS
               active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
               4 + 1N + 0XS + 1X >= 3 + 0N + 0XS + 0X
               active splitAt(X1, X2) -> splitAt(active X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               active splitAt(X1, X2) -> splitAt(X1, active X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
               3 + 0X + 1YS + 1ZS >= 3 + 1X + 0YS + 1ZS
               active U12(X1, X2) -> U12(active X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
               3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               splitAt(mark X1, X2) -> mark splitAt(X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               splitAt(X1, mark X2) -> mark splitAt(X1, X2)
               2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               U12(ok X1, ok X2) -> ok U12(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               U12(mark X1, X2) -> mark U12(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
             Qed
    
    
    SCC (3):
     Strict:
      { take#(X1, mark X2) -> take#(X1, X2),
        take#(mark X1, X2) -> take#(X1, X2),
       take#(ok X1, ok X2) -> take#(X1, X2)}
     Weak:
     {                U12(mark X1, X2) -> mark U12(X1, X2),
                     U12(ok X1, ok X2) -> ok U12(X1, X2),
                  splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                  splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                 splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                    active U12(X1, X2) -> U12(active X1, X2),
           active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                active splitAt(X1, X2) -> splitAt(X1, active X2),
                active splitAt(X1, X2) -> splitAt(active X1, X2),
      active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
               active splitAt(0(), XS) -> mark pair(nil(), XS),
            active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
            active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                   active pair(X1, X2) -> pair(X1, active X2),
                   active pair(X1, X2) -> pair(active X1, X2),
                   active cons(X1, X2) -> cons(active X1, X2),
                          active snd X -> snd active X,
                 active snd pair(X, Y) -> mark Y,
                active afterNth(N, XS) -> mark snd splitAt(N, XS),
               active afterNth(X1, X2) -> afterNth(X1, active X2),
               active afterNth(X1, X2) -> afterNth(active X1, X2),
                    active and(X1, X2) -> and(active X1, X2),
                   active and(tt(), X) -> mark X,
                          active fst X -> fst active X,
                 active fst pair(X, Y) -> mark X,
                         active head X -> head active X,
               active head cons(N, XS) -> mark N,
                     active natsFrom N -> mark cons(N, natsFrom s N),
                     active natsFrom X -> natsFrom active X,
                            active s X -> s active X,
                     active sel(N, XS) -> mark head afterNth(N, XS),
                    active sel(X1, X2) -> sel(X1, active X2),
                    active sel(X1, X2) -> sel(active X1, X2),
                         active tail X -> tail active X,
               active tail cons(N, XS) -> mark XS,
                    active take(N, XS) -> mark fst splitAt(N, XS),
                   active take(X1, X2) -> take(X1, active X2),
                   active take(X1, X2) -> take(active X1, X2),
              U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
       U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                     pair(X1, mark X2) -> mark pair(X1, X2),
                     pair(mark X1, X2) -> mark pair(X1, X2),
                    pair(ok X1, ok X2) -> ok pair(X1, X2),
                     cons(mark X1, X2) -> mark cons(X1, X2),
                    cons(ok X1, ok X2) -> ok cons(X1, X2),
                            snd mark X -> mark snd X,
                              snd ok X -> ok snd X,
                 afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                 afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                      and(mark X1, X2) -> mark and(X1, X2),
                     and(ok X1, ok X2) -> ok and(X1, X2),
                            fst mark X -> mark fst X,
                              fst ok X -> ok fst X,
                           head mark X -> mark head X,
                             head ok X -> ok head X,
                       natsFrom mark X -> mark natsFrom X,
                         natsFrom ok X -> ok natsFrom X,
                              s mark X -> mark s X,
                                s ok X -> ok s X,
                      sel(X1, mark X2) -> mark sel(X1, X2),
                      sel(mark X1, X2) -> mark sel(X1, X2),
                     sel(ok X1, ok X2) -> ok sel(X1, X2),
                           tail mark X -> mark tail X,
                             tail ok X -> ok tail X,
                     take(X1, mark X2) -> mark take(X1, X2),
                     take(mark X1, X2) -> mark take(X1, X2),
                    take(ok X1, ok X2) -> ok take(X1, X2),
                    proper U12(X1, X2) -> U12(proper X1, proper X2),
                proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
            proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                           proper tt() -> ok tt(),
                   proper pair(X1, X2) -> pair(proper X1, proper X2),
                   proper cons(X1, X2) -> cons(proper X1, proper X2),
                          proper snd X -> snd proper X,
               proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                    proper and(X1, X2) -> and(proper X1, proper X2),
                          proper fst X -> fst proper X,
                         proper head X -> head proper X,
                     proper natsFrom X -> natsFrom proper X,
                            proper s X -> s proper X,
                    proper sel(X1, X2) -> sel(proper X1, proper X2),
                          proper nil() -> ok nil(),
                            proper 0() -> ok 0(),
                         proper tail X -> tail proper X,
                   proper take(X1, X2) -> take(proper X1, proper X2),
                            top mark X -> top proper X,
                              top ok X -> top active X}
     POLY:
      Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
      Interpretation:
       [U11](x0, x1, x2, x3) = x0 + 1,
       
       [U12](x0, x1) = 0,
       
       [splitAt](x0, x1) = x0 + 1,
       
       [pair](x0, x1) = x0 + x1 + 1,
       
       [cons](x0, x1) = 1,
       
       [afterNth](x0, x1) = 0,
       
       [and](x0, x1) = 0,
       
       [sel](x0, x1) = 0,
       
       [take](x0, x1) = 0,
       
       [mark](x0) = x0 + 1,
       
       [active](x0) = 0,
       
       [snd](x0) = 0,
       
       [fst](x0) = x0,
       
       [head](x0) = 0,
       
       [natsFrom](x0) = x0 + 1,
       
       [s](x0) = 1,
       
       [tail](x0) = x0 + 1,
       
       [proper](x0) = 0,
       
       [ok](x0) = x0 + 1,
       
       [top](x0) = 0,
       
       [tt] = 1,
       
       [nil] = 1,
       
       [0] = 1,
       
       [take#](x0, x1) = x0 + 1
      Strict:
       take#(ok X1, ok X2) -> take#(X1, X2)
       2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
       take#(mark X1, X2) -> take#(X1, X2)
       2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
       take#(X1, mark X2) -> take#(X1, X2)
       1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
      Weak:
       top ok X -> top active X
       0 + 0X >= 0 + 0X
       top mark X -> top proper X
       0 + 0X >= 0 + 0X
       proper take(X1, X2) -> take(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper tail X -> tail proper X
       0 + 0X >= 1 + 0X
       proper 0() -> ok 0()
       0 >= 2
       proper nil() -> ok nil()
       0 >= 2
       proper sel(X1, X2) -> sel(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper s X -> s proper X
       0 + 0X >= 1 + 0X
       proper natsFrom X -> natsFrom proper X
       0 + 0X >= 1 + 0X
       proper head X -> head proper X
       0 + 0X >= 0 + 0X
       proper fst X -> fst proper X
       0 + 0X >= 0 + 0X
       proper and(X1, X2) -> and(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper snd X -> snd proper X
       0 + 0X >= 0 + 0X
       proper cons(X1, X2) -> cons(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper pair(X1, X2) -> pair(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper tt() -> ok tt()
       0 >= 2
       proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
       0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
       proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper U12(X1, X2) -> U12(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       take(ok X1, ok X2) -> ok take(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       take(mark X1, X2) -> mark take(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       take(X1, mark X2) -> mark take(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       tail ok X -> ok tail X
       2 + 1X >= 2 + 1X
       tail mark X -> mark tail X
       2 + 1X >= 2 + 1X
       sel(ok X1, ok X2) -> ok sel(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       sel(mark X1, X2) -> mark sel(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       sel(X1, mark X2) -> mark sel(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       s ok X -> ok s X
       1 + 0X >= 2 + 0X
       s mark X -> mark s X
       1 + 0X >= 2 + 0X
       natsFrom ok X -> ok natsFrom X
       2 + 1X >= 2 + 1X
       natsFrom mark X -> mark natsFrom X
       2 + 1X >= 2 + 1X
       head ok X -> ok head X
       0 + 0X >= 1 + 0X
       head mark X -> mark head X
       0 + 0X >= 1 + 0X
       fst ok X -> ok fst X
       1 + 1X >= 1 + 1X
       fst mark X -> mark fst X
       1 + 1X >= 1 + 1X
       and(ok X1, ok X2) -> ok and(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       and(mark X1, X2) -> mark and(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       afterNth(mark X1, X2) -> mark afterNth(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       afterNth(X1, mark X2) -> mark afterNth(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       snd ok X -> ok snd X
       0 + 0X >= 1 + 0X
       snd mark X -> mark snd X
       0 + 0X >= 1 + 0X
       cons(ok X1, ok X2) -> ok cons(X1, X2)
       1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
       cons(mark X1, X2) -> mark cons(X1, X2)
       1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
       pair(ok X1, ok X2) -> ok pair(X1, X2)
       3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
       pair(mark X1, X2) -> mark pair(X1, X2)
       2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
       pair(X1, mark X2) -> mark pair(X1, X2)
       2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
       U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
       2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
       U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
       2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
       active take(X1, X2) -> take(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active take(X1, X2) -> take(X1, active X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active take(N, XS) -> mark fst splitAt(N, XS)
       0 + 0N + 0XS >= 2 + 0N + 1XS
       active tail cons(N, XS) -> mark XS
       0 + 0N + 0XS >= 1 + 1XS
       active tail X -> tail active X
       0 + 0X >= 1 + 0X
       active sel(X1, X2) -> sel(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active sel(X1, X2) -> sel(X1, active X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active sel(N, XS) -> mark head afterNth(N, XS)
       0 + 0N + 0XS >= 1 + 0N + 0XS
       active s X -> s active X
       0 + 0X >= 1 + 0X
       active natsFrom X -> natsFrom active X
       0 + 0X >= 1 + 0X
       active natsFrom N -> mark cons(N, natsFrom s N)
       0 + 0N >= 2 + 0N
       active head cons(N, XS) -> mark N
       0 + 0N + 0XS >= 1 + 1N
       active head X -> head active X
       0 + 0X >= 0 + 0X
       active fst pair(X, Y) -> mark X
       0 + 0X + 0Y >= 1 + 1X
       active fst X -> fst active X
       0 + 0X >= 0 + 0X
       active and(tt(), X) -> mark X
       0 + 0X >= 1 + 1X
       active and(X1, X2) -> and(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active afterNth(X1, X2) -> afterNth(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active afterNth(X1, X2) -> afterNth(X1, active X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active afterNth(N, XS) -> mark snd splitAt(N, XS)
       0 + 0N + 0XS >= 1 + 0N + 0XS
       active snd pair(X, Y) -> mark Y
       0 + 0X + 0Y >= 1 + 1Y
       active snd X -> snd active X
       0 + 0X >= 0 + 0X
       active cons(X1, X2) -> cons(active X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       active pair(X1, X2) -> pair(active X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
       active pair(X1, X2) -> pair(X1, active X2)
       0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
       active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
       0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
       active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
       0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
       active splitAt(0(), XS) -> mark pair(nil(), XS)
       0 + 0XS >= 3 + 1XS
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
       0 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
       active splitAt(X1, X2) -> splitAt(active X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
       active splitAt(X1, X2) -> splitAt(X1, active X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
       0 + 0X + 0YS + 0ZS >= 3 + 0X + 0YS + 1ZS
       active U12(X1, X2) -> U12(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       splitAt(mark X1, X2) -> mark splitAt(X1, X2)
       1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       splitAt(X1, mark X2) -> mark splitAt(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       U12(ok X1, ok X2) -> ok U12(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       U12(mark X1, X2) -> mark U12(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     SCCS (1):
      Scc:
       {take#(X1, mark X2) -> take#(X1, X2)}
      
      SCC (1):
       Strict:
        {take#(X1, mark X2) -> take#(X1, X2)}
       Weak:
       {                U12(mark X1, X2) -> mark U12(X1, X2),
                       U12(ok X1, ok X2) -> ok U12(X1, X2),
                    splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                    splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                      active U12(X1, X2) -> U12(active X1, X2),
             active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                  active splitAt(X1, X2) -> splitAt(X1, active X2),
                  active splitAt(X1, X2) -> splitAt(active X1, X2),
        active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                 active splitAt(0(), XS) -> mark pair(nil(), XS),
              active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
              active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                     active pair(X1, X2) -> pair(X1, active X2),
                     active pair(X1, X2) -> pair(active X1, X2),
                     active cons(X1, X2) -> cons(active X1, X2),
                            active snd X -> snd active X,
                   active snd pair(X, Y) -> mark Y,
                  active afterNth(N, XS) -> mark snd splitAt(N, XS),
                 active afterNth(X1, X2) -> afterNth(X1, active X2),
                 active afterNth(X1, X2) -> afterNth(active X1, X2),
                      active and(X1, X2) -> and(active X1, X2),
                     active and(tt(), X) -> mark X,
                            active fst X -> fst active X,
                   active fst pair(X, Y) -> mark X,
                           active head X -> head active X,
                 active head cons(N, XS) -> mark N,
                       active natsFrom N -> mark cons(N, natsFrom s N),
                       active natsFrom X -> natsFrom active X,
                              active s X -> s active X,
                       active sel(N, XS) -> mark head afterNth(N, XS),
                      active sel(X1, X2) -> sel(X1, active X2),
                      active sel(X1, X2) -> sel(active X1, X2),
                           active tail X -> tail active X,
                 active tail cons(N, XS) -> mark XS,
                      active take(N, XS) -> mark fst splitAt(N, XS),
                     active take(X1, X2) -> take(X1, active X2),
                     active take(X1, X2) -> take(active X1, X2),
                U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
         U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                       pair(X1, mark X2) -> mark pair(X1, X2),
                       pair(mark X1, X2) -> mark pair(X1, X2),
                      pair(ok X1, ok X2) -> ok pair(X1, X2),
                       cons(mark X1, X2) -> mark cons(X1, X2),
                      cons(ok X1, ok X2) -> ok cons(X1, X2),
                              snd mark X -> mark snd X,
                                snd ok X -> ok snd X,
                   afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                   afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                  afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                        and(mark X1, X2) -> mark and(X1, X2),
                       and(ok X1, ok X2) -> ok and(X1, X2),
                              fst mark X -> mark fst X,
                                fst ok X -> ok fst X,
                             head mark X -> mark head X,
                               head ok X -> ok head X,
                         natsFrom mark X -> mark natsFrom X,
                           natsFrom ok X -> ok natsFrom X,
                                s mark X -> mark s X,
                                  s ok X -> ok s X,
                        sel(X1, mark X2) -> mark sel(X1, X2),
                        sel(mark X1, X2) -> mark sel(X1, X2),
                       sel(ok X1, ok X2) -> ok sel(X1, X2),
                             tail mark X -> mark tail X,
                               tail ok X -> ok tail X,
                       take(X1, mark X2) -> mark take(X1, X2),
                       take(mark X1, X2) -> mark take(X1, X2),
                      take(ok X1, ok X2) -> ok take(X1, X2),
                      proper U12(X1, X2) -> U12(proper X1, proper X2),
                  proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
              proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                             proper tt() -> ok tt(),
                     proper pair(X1, X2) -> pair(proper X1, proper X2),
                     proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper snd X -> snd proper X,
                 proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                      proper and(X1, X2) -> and(proper X1, proper X2),
                            proper fst X -> fst proper X,
                           proper head X -> head proper X,
                       proper natsFrom X -> natsFrom proper X,
                              proper s X -> s proper X,
                      proper sel(X1, X2) -> sel(proper X1, proper X2),
                            proper nil() -> ok nil(),
                              proper 0() -> ok 0(),
                           proper tail X -> tail proper X,
                     proper take(X1, X2) -> take(proper X1, proper X2),
                              top mark X -> top proper X,
                                top ok X -> top active X}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [U11](x0, x1, x2, x3) = x0 + 1,
         
         [U12](x0, x1) = x0 + 1,
         
         [splitAt](x0, x1) = x0 + 1,
         
         [pair](x0, x1) = x0 + 1,
         
         [cons](x0, x1) = 1,
         
         [afterNth](x0, x1) = x0 + 1,
         
         [and](x0, x1) = x0 + 1,
         
         [sel](x0, x1) = x0 + 1,
         
         [take](x0, x1) = x0 + 1,
         
         [mark](x0) = x0 + 1,
         
         [active](x0) = x0 + 1,
         
         [snd](x0) = x0 + 1,
         
         [fst](x0) = x0 + 1,
         
         [head](x0) = x0 + 1,
         
         [natsFrom](x0) = x0 + 1,
         
         [s](x0) = 1,
         
         [tail](x0) = x0 + 1,
         
         [proper](x0) = x0 + 1,
         
         [ok](x0) = x0 + 1,
         
         [top](x0) = x0 + 1,
         
         [tt] = 1,
         
         [nil] = 1,
         
         [0] = 0,
         
         [take#](x0, x1) = x0 + 1
        Strict:
         take#(X1, mark X2) -> take#(X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        Weak:
         top ok X -> top active X
         2 + 1X >= 2 + 1X
         top mark X -> top proper X
         2 + 1X >= 2 + 1X
         proper take(X1, X2) -> take(proper X1, proper X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         proper tail X -> tail proper X
         2 + 1X >= 2 + 1X
         proper 0() -> ok 0()
         1 >= 1
         proper nil() -> ok nil()
         2 >= 2
         proper sel(X1, X2) -> sel(proper X1, proper X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         proper s X -> s proper X
         2 + 0X >= 1 + 0X
         proper natsFrom X -> natsFrom proper X
         2 + 1X >= 2 + 1X
         proper head X -> head proper X
         2 + 1X >= 2 + 1X
         proper fst X -> fst proper X
         2 + 1X >= 2 + 1X
         proper and(X1, X2) -> and(proper X1, proper X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         proper snd X -> snd proper X
         2 + 1X >= 2 + 1X
         proper cons(X1, X2) -> cons(proper X1, proper X2)
         2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper pair(X1, X2) -> pair(proper X1, proper X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         proper tt() -> ok tt()
         2 >= 2
         proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
         2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
         proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         proper U12(X1, X2) -> U12(proper X1, proper X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         take(ok X1, ok X2) -> ok take(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         take(mark X1, X2) -> mark take(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         take(X1, mark X2) -> mark take(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         tail ok X -> ok tail X
         2 + 1X >= 2 + 1X
         tail mark X -> mark tail X
         2 + 1X >= 2 + 1X
         sel(ok X1, ok X2) -> ok sel(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         sel(mark X1, X2) -> mark sel(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         sel(X1, mark X2) -> mark sel(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         s ok X -> ok s X
         1 + 0X >= 2 + 0X
         s mark X -> mark s X
         1 + 0X >= 2 + 0X
         natsFrom ok X -> ok natsFrom X
         2 + 1X >= 2 + 1X
         natsFrom mark X -> mark natsFrom X
         2 + 1X >= 2 + 1X
         head ok X -> ok head X
         2 + 1X >= 2 + 1X
         head mark X -> mark head X
         2 + 1X >= 2 + 1X
         fst ok X -> ok fst X
         2 + 1X >= 2 + 1X
         fst mark X -> mark fst X
         2 + 1X >= 2 + 1X
         and(ok X1, ok X2) -> ok and(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         and(mark X1, X2) -> mark and(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         afterNth(mark X1, X2) -> mark afterNth(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         afterNth(X1, mark X2) -> mark afterNth(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         snd ok X -> ok snd X
         2 + 1X >= 2 + 1X
         snd mark X -> mark snd X
         2 + 1X >= 2 + 1X
         cons(ok X1, ok X2) -> ok cons(X1, X2)
         1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
         cons(mark X1, X2) -> mark cons(X1, X2)
         1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
         pair(ok X1, ok X2) -> ok pair(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         pair(mark X1, X2) -> mark pair(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         pair(X1, mark X2) -> mark pair(X1, X2)
         1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
         2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
         U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
         2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
         active take(X1, X2) -> take(active X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
         active take(X1, X2) -> take(X1, active X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         active take(N, XS) -> mark fst splitAt(N, XS)
         2 + 0N + 1XS >= 3 + 0N + 1XS
         active tail cons(N, XS) -> mark XS
         3 + 0N + 0XS >= 1 + 1XS
         active tail X -> tail active X
         2 + 1X >= 2 + 1X
         active sel(X1, X2) -> sel(active X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
         active sel(X1, X2) -> sel(X1, active X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         active sel(N, XS) -> mark head afterNth(N, XS)
         2 + 0N + 1XS >= 3 + 0N + 1XS
         active s X -> s active X
         2 + 0X >= 1 + 0X
         active natsFrom X -> natsFrom active X
         2 + 1X >= 2 + 1X
         active natsFrom N -> mark cons(N, natsFrom s N)
         2 + 1N >= 2 + 0N
         active head cons(N, XS) -> mark N
         3 + 0N + 0XS >= 1 + 1N
         active head X -> head active X
         2 + 1X >= 2 + 1X
         active fst pair(X, Y) -> mark X
         3 + 1X + 0Y >= 1 + 1X
         active fst X -> fst active X
         2 + 1X >= 2 + 1X
         active and(tt(), X) -> mark X
         3 + 0X >= 1 + 1X
         active and(X1, X2) -> and(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         active afterNth(X1, X2) -> afterNth(active X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
         active afterNth(X1, X2) -> afterNth(X1, active X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         active afterNth(N, XS) -> mark snd splitAt(N, XS)
         2 + 0N + 1XS >= 3 + 0N + 1XS
         active snd pair(X, Y) -> mark Y
         3 + 1X + 0Y >= 1 + 1Y
         active snd X -> snd active X
         2 + 1X >= 2 + 1X
         active cons(X1, X2) -> cons(active X1, X2)
         2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         active pair(X1, X2) -> pair(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         active pair(X1, X2) -> pair(X1, active X2)
         2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
         3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
         active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
         2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
         active splitAt(0(), XS) -> mark pair(nil(), XS)
         2 + 1XS >= 3 + 0XS
         active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
         3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
         active splitAt(X1, X2) -> splitAt(active X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
         active splitAt(X1, X2) -> splitAt(X1, active X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
         3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
         active U12(X1, X2) -> U12(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         splitAt(mark X1, X2) -> mark splitAt(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         splitAt(X1, mark X2) -> mark splitAt(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         U12(ok X1, ok X2) -> ok U12(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         U12(mark X1, X2) -> mark U12(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       Qed
   
   
   
   SCC (2):
    Strict:
     {tail# mark X -> tail# X,
        tail# ok X -> tail# X}
    Weak:
    {                U12(mark X1, X2) -> mark U12(X1, X2),
                    U12(ok X1, ok X2) -> ok U12(X1, X2),
                 splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                 splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                   active U12(X1, X2) -> U12(active X1, X2),
          active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
               active splitAt(X1, X2) -> splitAt(X1, active X2),
               active splitAt(X1, X2) -> splitAt(active X1, X2),
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
              active splitAt(0(), XS) -> mark pair(nil(), XS),
           active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
           active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active pair(X1, X2) -> pair(X1, active X2),
                  active pair(X1, X2) -> pair(active X1, X2),
                  active cons(X1, X2) -> cons(active X1, X2),
                         active snd X -> snd active X,
                active snd pair(X, Y) -> mark Y,
               active afterNth(N, XS) -> mark snd splitAt(N, XS),
              active afterNth(X1, X2) -> afterNth(X1, active X2),
              active afterNth(X1, X2) -> afterNth(active X1, X2),
                   active and(X1, X2) -> and(active X1, X2),
                  active and(tt(), X) -> mark X,
                         active fst X -> fst active X,
                active fst pair(X, Y) -> mark X,
                        active head X -> head active X,
              active head cons(N, XS) -> mark N,
                    active natsFrom N -> mark cons(N, natsFrom s N),
                    active natsFrom X -> natsFrom active X,
                           active s X -> s active X,
                    active sel(N, XS) -> mark head afterNth(N, XS),
                   active sel(X1, X2) -> sel(X1, active X2),
                   active sel(X1, X2) -> sel(active X1, X2),
                        active tail X -> tail active X,
              active tail cons(N, XS) -> mark XS,
                   active take(N, XS) -> mark fst splitAt(N, XS),
                  active take(X1, X2) -> take(X1, active X2),
                  active take(X1, X2) -> take(active X1, X2),
             U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
      U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                    pair(X1, mark X2) -> mark pair(X1, X2),
                    pair(mark X1, X2) -> mark pair(X1, X2),
                   pair(ok X1, ok X2) -> ok pair(X1, X2),
                    cons(mark X1, X2) -> mark cons(X1, X2),
                   cons(ok X1, ok X2) -> ok cons(X1, X2),
                           snd mark X -> mark snd X,
                             snd ok X -> ok snd X,
                afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                afterNth(mark X1, X2) -> mark afterNth(X1, X2),
               afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                     and(mark X1, X2) -> mark and(X1, X2),
                    and(ok X1, ok X2) -> ok and(X1, X2),
                           fst mark X -> mark fst X,
                             fst ok X -> ok fst X,
                          head mark X -> mark head X,
                            head ok X -> ok head X,
                      natsFrom mark X -> mark natsFrom X,
                        natsFrom ok X -> ok natsFrom X,
                             s mark X -> mark s X,
                               s ok X -> ok s X,
                     sel(X1, mark X2) -> mark sel(X1, X2),
                     sel(mark X1, X2) -> mark sel(X1, X2),
                    sel(ok X1, ok X2) -> ok sel(X1, X2),
                          tail mark X -> mark tail X,
                            tail ok X -> ok tail X,
                    take(X1, mark X2) -> mark take(X1, X2),
                    take(mark X1, X2) -> mark take(X1, X2),
                   take(ok X1, ok X2) -> ok take(X1, X2),
                   proper U12(X1, X2) -> U12(proper X1, proper X2),
               proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
           proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                          proper tt() -> ok tt(),
                  proper pair(X1, X2) -> pair(proper X1, proper X2),
                  proper cons(X1, X2) -> cons(proper X1, proper X2),
                         proper snd X -> snd proper X,
              proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                   proper and(X1, X2) -> and(proper X1, proper X2),
                         proper fst X -> fst proper X,
                        proper head X -> head proper X,
                    proper natsFrom X -> natsFrom proper X,
                           proper s X -> s proper X,
                   proper sel(X1, X2) -> sel(proper X1, proper X2),
                         proper nil() -> ok nil(),
                           proper 0() -> ok 0(),
                        proper tail X -> tail proper X,
                  proper take(X1, X2) -> take(proper X1, proper X2),
                           top mark X -> top proper X,
                             top ok X -> top active X}
    POLY:
     Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
     Interpretation:
      [U11](x0, x1, x2, x3) = x0 + 1,
      
      [U12](x0, x1) = x0 + 1,
      
      [splitAt](x0, x1) = 0,
      
      [pair](x0, x1) = x0 + 1,
      
      [cons](x0, x1) = 1,
      
      [afterNth](x0, x1) = x0 + 1,
      
      [and](x0, x1) = x0 + 1,
      
      [sel](x0, x1) = x0 + 1,
      
      [take](x0, x1) = x0 + 1,
      
      [mark](x0) = x0 + 1,
      
      [active](x0) = x0 + 1,
      
      [snd](x0) = x0 + 1,
      
      [fst](x0) = x0 + 1,
      
      [head](x0) = x0 + 1,
      
      [natsFrom](x0) = x0 + 1,
      
      [s](x0) = 1,
      
      [tail](x0) = x0 + 1,
      
      [proper](x0) = x0 + 1,
      
      [ok](x0) = x0 + 1,
      
      [top](x0) = 0,
      
      [tt] = 1,
      
      [nil] = 1,
      
      [0] = 1,
      
      [tail#](x0) = x0 + 1
     Strict:
      tail# ok X -> tail# X
      2 + 1X >= 1 + 1X
      tail# mark X -> tail# X
      2 + 1X >= 1 + 1X
     Weak:
      top ok X -> top active X
      0 + 0X >= 0 + 0X
      top mark X -> top proper X
      0 + 0X >= 0 + 0X
      proper take(X1, X2) -> take(proper X1, proper X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      proper tail X -> tail proper X
      2 + 1X >= 2 + 1X
      proper 0() -> ok 0()
      2 >= 2
      proper nil() -> ok nil()
      2 >= 2
      proper sel(X1, X2) -> sel(proper X1, proper X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      proper s X -> s proper X
      2 + 0X >= 1 + 0X
      proper natsFrom X -> natsFrom proper X
      2 + 1X >= 2 + 1X
      proper head X -> head proper X
      2 + 1X >= 2 + 1X
      proper fst X -> fst proper X
      2 + 1X >= 2 + 1X
      proper and(X1, X2) -> and(proper X1, proper X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      proper snd X -> snd proper X
      2 + 1X >= 2 + 1X
      proper cons(X1, X2) -> cons(proper X1, proper X2)
      2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper pair(X1, X2) -> pair(proper X1, proper X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      proper tt() -> ok tt()
      2 >= 2
      proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
      2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
      proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
      1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      proper U12(X1, X2) -> U12(proper X1, proper X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      take(ok X1, ok X2) -> ok take(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      take(mark X1, X2) -> mark take(X1, X2)
      1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      take(X1, mark X2) -> mark take(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      tail ok X -> ok tail X
      2 + 1X >= 2 + 1X
      tail mark X -> mark tail X
      2 + 1X >= 2 + 1X
      sel(ok X1, ok X2) -> ok sel(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      sel(mark X1, X2) -> mark sel(X1, X2)
      1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      sel(X1, mark X2) -> mark sel(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      s ok X -> ok s X
      1 + 0X >= 2 + 0X
      s mark X -> mark s X
      1 + 0X >= 2 + 0X
      natsFrom ok X -> ok natsFrom X
      2 + 1X >= 2 + 1X
      natsFrom mark X -> mark natsFrom X
      2 + 1X >= 2 + 1X
      head ok X -> ok head X
      2 + 1X >= 2 + 1X
      head mark X -> mark head X
      2 + 1X >= 2 + 1X
      fst ok X -> ok fst X
      2 + 1X >= 2 + 1X
      fst mark X -> mark fst X
      2 + 1X >= 2 + 1X
      and(ok X1, ok X2) -> ok and(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      and(mark X1, X2) -> mark and(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      afterNth(mark X1, X2) -> mark afterNth(X1, X2)
      1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      afterNth(X1, mark X2) -> mark afterNth(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      snd ok X -> ok snd X
      2 + 1X >= 2 + 1X
      snd mark X -> mark snd X
      2 + 1X >= 2 + 1X
      cons(ok X1, ok X2) -> ok cons(X1, X2)
      1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
      cons(mark X1, X2) -> mark cons(X1, X2)
      1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
      pair(ok X1, ok X2) -> ok pair(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      pair(mark X1, X2) -> mark pair(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      pair(X1, mark X2) -> mark pair(X1, X2)
      1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
      2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
      U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
      2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
      active take(X1, X2) -> take(active X1, X2)
      2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
      active take(X1, X2) -> take(X1, active X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      active take(N, XS) -> mark fst splitAt(N, XS)
      2 + 0N + 1XS >= 2 + 0N + 0XS
      active tail cons(N, XS) -> mark XS
      3 + 0N + 0XS >= 1 + 1XS
      active tail X -> tail active X
      2 + 1X >= 2 + 1X
      active sel(X1, X2) -> sel(active X1, X2)
      2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
      active sel(X1, X2) -> sel(X1, active X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      active sel(N, XS) -> mark head afterNth(N, XS)
      2 + 0N + 1XS >= 3 + 0N + 1XS
      active s X -> s active X
      2 + 0X >= 1 + 0X
      active natsFrom X -> natsFrom active X
      2 + 1X >= 2 + 1X
      active natsFrom N -> mark cons(N, natsFrom s N)
      2 + 1N >= 2 + 0N
      active head cons(N, XS) -> mark N
      3 + 0N + 0XS >= 1 + 1N
      active head X -> head active X
      2 + 1X >= 2 + 1X
      active fst pair(X, Y) -> mark X
      3 + 1X + 0Y >= 1 + 1X
      active fst X -> fst active X
      2 + 1X >= 2 + 1X
      active and(tt(), X) -> mark X
      3 + 0X >= 1 + 1X
      active and(X1, X2) -> and(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      active afterNth(X1, X2) -> afterNth(active X1, X2)
      2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
      active afterNth(X1, X2) -> afterNth(X1, active X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      active afterNth(N, XS) -> mark snd splitAt(N, XS)
      2 + 0N + 1XS >= 2 + 0N + 0XS
      active snd pair(X, Y) -> mark Y
      3 + 1X + 0Y >= 1 + 1Y
      active snd X -> snd active X
      2 + 1X >= 2 + 1X
      active cons(X1, X2) -> cons(active X1, X2)
      2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      active pair(X1, X2) -> pair(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      active pair(X1, X2) -> pair(X1, active X2)
      2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
      active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
      3 + 0N + 0XS + 0X >= 2 + 0N + 0XS + 0X
      active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
      2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
      active splitAt(0(), XS) -> mark pair(nil(), XS)
      1 + 0XS >= 3 + 0XS
      active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
      1 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
      active splitAt(X1, X2) -> splitAt(active X1, X2)
      1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active splitAt(X1, X2) -> splitAt(X1, active X2)
      1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
      3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
      active U12(X1, X2) -> U12(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      splitAt(mark X1, X2) -> mark splitAt(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      splitAt(X1, mark X2) -> mark splitAt(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      U12(ok X1, ok X2) -> ok U12(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      U12(mark X1, X2) -> mark U12(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    Qed
   
   
   SCC (3):
    Strict:
     { sel#(X1, mark X2) -> sel#(X1, X2),
       sel#(mark X1, X2) -> sel#(X1, X2),
      sel#(ok X1, ok X2) -> sel#(X1, X2)}
    Weak:
    {                U12(mark X1, X2) -> mark U12(X1, X2),
                    U12(ok X1, ok X2) -> ok U12(X1, X2),
                 splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                 splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                   active U12(X1, X2) -> U12(active X1, X2),
          active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
               active splitAt(X1, X2) -> splitAt(X1, active X2),
               active splitAt(X1, X2) -> splitAt(active X1, X2),
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
              active splitAt(0(), XS) -> mark pair(nil(), XS),
           active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
           active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active pair(X1, X2) -> pair(X1, active X2),
                  active pair(X1, X2) -> pair(active X1, X2),
                  active cons(X1, X2) -> cons(active X1, X2),
                         active snd X -> snd active X,
                active snd pair(X, Y) -> mark Y,
               active afterNth(N, XS) -> mark snd splitAt(N, XS),
              active afterNth(X1, X2) -> afterNth(X1, active X2),
              active afterNth(X1, X2) -> afterNth(active X1, X2),
                   active and(X1, X2) -> and(active X1, X2),
                  active and(tt(), X) -> mark X,
                         active fst X -> fst active X,
                active fst pair(X, Y) -> mark X,
                        active head X -> head active X,
              active head cons(N, XS) -> mark N,
                    active natsFrom N -> mark cons(N, natsFrom s N),
                    active natsFrom X -> natsFrom active X,
                           active s X -> s active X,
                    active sel(N, XS) -> mark head afterNth(N, XS),
                   active sel(X1, X2) -> sel(X1, active X2),
                   active sel(X1, X2) -> sel(active X1, X2),
                        active tail X -> tail active X,
              active tail cons(N, XS) -> mark XS,
                   active take(N, XS) -> mark fst splitAt(N, XS),
                  active take(X1, X2) -> take(X1, active X2),
                  active take(X1, X2) -> take(active X1, X2),
             U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
      U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                    pair(X1, mark X2) -> mark pair(X1, X2),
                    pair(mark X1, X2) -> mark pair(X1, X2),
                   pair(ok X1, ok X2) -> ok pair(X1, X2),
                    cons(mark X1, X2) -> mark cons(X1, X2),
                   cons(ok X1, ok X2) -> ok cons(X1, X2),
                           snd mark X -> mark snd X,
                             snd ok X -> ok snd X,
                afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                afterNth(mark X1, X2) -> mark afterNth(X1, X2),
               afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                     and(mark X1, X2) -> mark and(X1, X2),
                    and(ok X1, ok X2) -> ok and(X1, X2),
                           fst mark X -> mark fst X,
                             fst ok X -> ok fst X,
                          head mark X -> mark head X,
                            head ok X -> ok head X,
                      natsFrom mark X -> mark natsFrom X,
                        natsFrom ok X -> ok natsFrom X,
                             s mark X -> mark s X,
                               s ok X -> ok s X,
                     sel(X1, mark X2) -> mark sel(X1, X2),
                     sel(mark X1, X2) -> mark sel(X1, X2),
                    sel(ok X1, ok X2) -> ok sel(X1, X2),
                          tail mark X -> mark tail X,
                            tail ok X -> ok tail X,
                    take(X1, mark X2) -> mark take(X1, X2),
                    take(mark X1, X2) -> mark take(X1, X2),
                   take(ok X1, ok X2) -> ok take(X1, X2),
                   proper U12(X1, X2) -> U12(proper X1, proper X2),
               proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
           proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                          proper tt() -> ok tt(),
                  proper pair(X1, X2) -> pair(proper X1, proper X2),
                  proper cons(X1, X2) -> cons(proper X1, proper X2),
                         proper snd X -> snd proper X,
              proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                   proper and(X1, X2) -> and(proper X1, proper X2),
                         proper fst X -> fst proper X,
                        proper head X -> head proper X,
                    proper natsFrom X -> natsFrom proper X,
                           proper s X -> s proper X,
                   proper sel(X1, X2) -> sel(proper X1, proper X2),
                         proper nil() -> ok nil(),
                           proper 0() -> ok 0(),
                        proper tail X -> tail proper X,
                  proper take(X1, X2) -> take(proper X1, proper X2),
                           top mark X -> top proper X,
                             top ok X -> top active X}
    POLY:
     Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
     Interpretation:
      [U11](x0, x1, x2, x3) = x0 + 1,
      
      [U12](x0, x1) = 0,
      
      [splitAt](x0, x1) = x0 + 1,
      
      [pair](x0, x1) = x0 + x1 + 1,
      
      [cons](x0, x1) = 1,
      
      [afterNth](x0, x1) = 0,
      
      [and](x0, x1) = 0,
      
      [sel](x0, x1) = 0,
      
      [take](x0, x1) = 0,
      
      [mark](x0) = x0 + 1,
      
      [active](x0) = 0,
      
      [snd](x0) = 0,
      
      [fst](x0) = x0,
      
      [head](x0) = 0,
      
      [natsFrom](x0) = x0 + 1,
      
      [s](x0) = 1,
      
      [tail](x0) = x0 + 1,
      
      [proper](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [top](x0) = 0,
      
      [tt] = 1,
      
      [nil] = 1,
      
      [0] = 1,
      
      [sel#](x0, x1) = x0 + 1
     Strict:
      sel#(ok X1, ok X2) -> sel#(X1, X2)
      2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
      sel#(mark X1, X2) -> sel#(X1, X2)
      2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
      sel#(X1, mark X2) -> sel#(X1, X2)
      1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     Weak:
      top ok X -> top active X
      0 + 0X >= 0 + 0X
      top mark X -> top proper X
      0 + 0X >= 0 + 0X
      proper take(X1, X2) -> take(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      proper tail X -> tail proper X
      0 + 0X >= 1 + 0X
      proper 0() -> ok 0()
      0 >= 2
      proper nil() -> ok nil()
      0 >= 2
      proper sel(X1, X2) -> sel(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      proper s X -> s proper X
      0 + 0X >= 1 + 0X
      proper natsFrom X -> natsFrom proper X
      0 + 0X >= 1 + 0X
      proper head X -> head proper X
      0 + 0X >= 0 + 0X
      proper fst X -> fst proper X
      0 + 0X >= 0 + 0X
      proper and(X1, X2) -> and(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      proper snd X -> snd proper X
      0 + 0X >= 0 + 0X
      proper cons(X1, X2) -> cons(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper pair(X1, X2) -> pair(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper tt() -> ok tt()
      0 >= 2
      proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
      0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
      proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper U12(X1, X2) -> U12(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      take(ok X1, ok X2) -> ok take(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      take(mark X1, X2) -> mark take(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      take(X1, mark X2) -> mark take(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      tail ok X -> ok tail X
      2 + 1X >= 2 + 1X
      tail mark X -> mark tail X
      2 + 1X >= 2 + 1X
      sel(ok X1, ok X2) -> ok sel(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      sel(mark X1, X2) -> mark sel(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      sel(X1, mark X2) -> mark sel(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      s ok X -> ok s X
      1 + 0X >= 2 + 0X
      s mark X -> mark s X
      1 + 0X >= 2 + 0X
      natsFrom ok X -> ok natsFrom X
      2 + 1X >= 2 + 1X
      natsFrom mark X -> mark natsFrom X
      2 + 1X >= 2 + 1X
      head ok X -> ok head X
      0 + 0X >= 1 + 0X
      head mark X -> mark head X
      0 + 0X >= 1 + 0X
      fst ok X -> ok fst X
      1 + 1X >= 1 + 1X
      fst mark X -> mark fst X
      1 + 1X >= 1 + 1X
      and(ok X1, ok X2) -> ok and(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      and(mark X1, X2) -> mark and(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      afterNth(mark X1, X2) -> mark afterNth(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      afterNth(X1, mark X2) -> mark afterNth(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      snd ok X -> ok snd X
      0 + 0X >= 1 + 0X
      snd mark X -> mark snd X
      0 + 0X >= 1 + 0X
      cons(ok X1, ok X2) -> ok cons(X1, X2)
      1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
      cons(mark X1, X2) -> mark cons(X1, X2)
      1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
      pair(ok X1, ok X2) -> ok pair(X1, X2)
      3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
      pair(mark X1, X2) -> mark pair(X1, X2)
      2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
      pair(X1, mark X2) -> mark pair(X1, X2)
      2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
      U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
      2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
      U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
      2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
      active take(X1, X2) -> take(active X1, X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active take(X1, X2) -> take(X1, active X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active take(N, XS) -> mark fst splitAt(N, XS)
      0 + 0N + 0XS >= 2 + 0N + 1XS
      active tail cons(N, XS) -> mark XS
      0 + 0N + 0XS >= 1 + 1XS
      active tail X -> tail active X
      0 + 0X >= 1 + 0X
      active sel(X1, X2) -> sel(active X1, X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active sel(X1, X2) -> sel(X1, active X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active sel(N, XS) -> mark head afterNth(N, XS)
      0 + 0N + 0XS >= 1 + 0N + 0XS
      active s X -> s active X
      0 + 0X >= 1 + 0X
      active natsFrom X -> natsFrom active X
      0 + 0X >= 1 + 0X
      active natsFrom N -> mark cons(N, natsFrom s N)
      0 + 0N >= 2 + 0N
      active head cons(N, XS) -> mark N
      0 + 0N + 0XS >= 1 + 1N
      active head X -> head active X
      0 + 0X >= 0 + 0X
      active fst pair(X, Y) -> mark X
      0 + 0X + 0Y >= 1 + 1X
      active fst X -> fst active X
      0 + 0X >= 0 + 0X
      active and(tt(), X) -> mark X
      0 + 0X >= 1 + 1X
      active and(X1, X2) -> and(active X1, X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active afterNth(X1, X2) -> afterNth(active X1, X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active afterNth(X1, X2) -> afterNth(X1, active X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      active afterNth(N, XS) -> mark snd splitAt(N, XS)
      0 + 0N + 0XS >= 1 + 0N + 0XS
      active snd pair(X, Y) -> mark Y
      0 + 0X + 0Y >= 1 + 1Y
      active snd X -> snd active X
      0 + 0X >= 0 + 0X
      active cons(X1, X2) -> cons(active X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      active pair(X1, X2) -> pair(active X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
      active pair(X1, X2) -> pair(X1, active X2)
      0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
      active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
      0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
      active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
      0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
      active splitAt(0(), XS) -> mark pair(nil(), XS)
      0 + 0XS >= 3 + 1XS
      active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
      0 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
      active splitAt(X1, X2) -> splitAt(active X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
      active splitAt(X1, X2) -> splitAt(X1, active X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
      0 + 0X + 0YS + 0ZS >= 3 + 0X + 0YS + 1ZS
      active U12(X1, X2) -> U12(active X1, X2)
      0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
      splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      splitAt(mark X1, X2) -> mark splitAt(X1, X2)
      1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      splitAt(X1, mark X2) -> mark splitAt(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      U12(ok X1, ok X2) -> ok U12(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      U12(mark X1, X2) -> mark U12(X1, X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    SCCS (1):
     Scc:
      {sel#(X1, mark X2) -> sel#(X1, X2)}
     
     SCC (1):
      Strict:
       {sel#(X1, mark X2) -> sel#(X1, X2)}
      Weak:
      {                U12(mark X1, X2) -> mark U12(X1, X2),
                      U12(ok X1, ok X2) -> ok U12(X1, X2),
                   splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                   splitAt(mark X1, X2) -> mark splitAt(X1, X2),
                  splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                     active U12(X1, X2) -> U12(active X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
                 active splitAt(X1, X2) -> splitAt(X1, active X2),
                 active splitAt(X1, X2) -> splitAt(active X1, X2),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                    active pair(X1, X2) -> pair(X1, active X2),
                    active pair(X1, X2) -> pair(active X1, X2),
                    active cons(X1, X2) -> cons(active X1, X2),
                           active snd X -> snd active X,
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                active afterNth(X1, X2) -> afterNth(X1, active X2),
                active afterNth(X1, X2) -> afterNth(active X1, X2),
                     active and(X1, X2) -> and(active X1, X2),
                    active and(tt(), X) -> mark X,
                           active fst X -> fst active X,
                  active fst pair(X, Y) -> mark X,
                          active head X -> head active X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active natsFrom X -> natsFrom active X,
                             active s X -> s active X,
                      active sel(N, XS) -> mark head afterNth(N, XS),
                     active sel(X1, X2) -> sel(X1, active X2),
                     active sel(X1, X2) -> sel(active X1, X2),
                          active tail X -> tail active X,
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
                    active take(X1, X2) -> take(X1, active X2),
                    active take(X1, X2) -> take(active X1, X2),
               U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
        U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> mark pair(X1, X2),
                      pair(mark X1, X2) -> mark pair(X1, X2),
                     pair(ok X1, ok X2) -> ok pair(X1, X2),
                      cons(mark X1, X2) -> mark cons(X1, X2),
                     cons(ok X1, ok X2) -> ok cons(X1, X2),
                             snd mark X -> mark snd X,
                               snd ok X -> ok snd X,
                  afterNth(X1, mark X2) -> mark afterNth(X1, X2),
                  afterNth(mark X1, X2) -> mark afterNth(X1, X2),
                 afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                       and(mark X1, X2) -> mark and(X1, X2),
                      and(ok X1, ok X2) -> ok and(X1, X2),
                             fst mark X -> mark fst X,
                               fst ok X -> ok fst X,
                            head mark X -> mark head X,
                              head ok X -> ok head X,
                        natsFrom mark X -> mark natsFrom X,
                          natsFrom ok X -> ok natsFrom X,
                               s mark X -> mark s X,
                                 s ok X -> ok s X,
                       sel(X1, mark X2) -> mark sel(X1, X2),
                       sel(mark X1, X2) -> mark sel(X1, X2),
                      sel(ok X1, ok X2) -> ok sel(X1, X2),
                            tail mark X -> mark tail X,
                              tail ok X -> ok tail X,
                      take(X1, mark X2) -> mark take(X1, X2),
                      take(mark X1, X2) -> mark take(X1, X2),
                     take(ok X1, ok X2) -> ok take(X1, X2),
                     proper U12(X1, X2) -> U12(proper X1, proper X2),
                 proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
             proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                            proper tt() -> ok tt(),
                    proper pair(X1, X2) -> pair(proper X1, proper X2),
                    proper cons(X1, X2) -> cons(proper X1, proper X2),
                           proper snd X -> snd proper X,
                proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                     proper and(X1, X2) -> and(proper X1, proper X2),
                           proper fst X -> fst proper X,
                          proper head X -> head proper X,
                      proper natsFrom X -> natsFrom proper X,
                             proper s X -> s proper X,
                     proper sel(X1, X2) -> sel(proper X1, proper X2),
                           proper nil() -> ok nil(),
                             proper 0() -> ok 0(),
                          proper tail X -> tail proper X,
                    proper take(X1, X2) -> take(proper X1, proper X2),
                             top mark X -> top proper X,
                               top ok X -> top active X}
      POLY:
       Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
       Interpretation:
        [U11](x0, x1, x2, x3) = x0 + 1,
        
        [U12](x0, x1) = x0 + 1,
        
        [splitAt](x0, x1) = x0 + 1,
        
        [pair](x0, x1) = x0 + 1,
        
        [cons](x0, x1) = 1,
        
        [afterNth](x0, x1) = x0 + 1,
        
        [and](x0, x1) = x0 + 1,
        
        [sel](x0, x1) = x0 + 1,
        
        [take](x0, x1) = x0 + 1,
        
        [mark](x0) = x0 + 1,
        
        [active](x0) = x0 + 1,
        
        [snd](x0) = x0 + 1,
        
        [fst](x0) = x0 + 1,
        
        [head](x0) = x0 + 1,
        
        [natsFrom](x0) = x0 + 1,
        
        [s](x0) = 1,
        
        [tail](x0) = x0 + 1,
        
        [proper](x0) = x0 + 1,
        
        [ok](x0) = x0 + 1,
        
        [top](x0) = x0 + 1,
        
        [tt] = 1,
        
        [nil] = 1,
        
        [0] = 0,
        
        [sel#](x0, x1) = x0 + 1
       Strict:
        sel#(X1, mark X2) -> sel#(X1, X2)
        2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       Weak:
        top ok X -> top active X
        2 + 1X >= 2 + 1X
        top mark X -> top proper X
        2 + 1X >= 2 + 1X
        proper take(X1, X2) -> take(proper X1, proper X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        proper tail X -> tail proper X
        2 + 1X >= 2 + 1X
        proper 0() -> ok 0()
        1 >= 1
        proper nil() -> ok nil()
        2 >= 2
        proper sel(X1, X2) -> sel(proper X1, proper X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        proper s X -> s proper X
        2 + 0X >= 1 + 0X
        proper natsFrom X -> natsFrom proper X
        2 + 1X >= 2 + 1X
        proper head X -> head proper X
        2 + 1X >= 2 + 1X
        proper fst X -> fst proper X
        2 + 1X >= 2 + 1X
        proper and(X1, X2) -> and(proper X1, proper X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        proper snd X -> snd proper X
        2 + 1X >= 2 + 1X
        proper cons(X1, X2) -> cons(proper X1, proper X2)
        2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
        proper pair(X1, X2) -> pair(proper X1, proper X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        proper tt() -> ok tt()
        2 >= 2
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
        2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
        proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        proper U12(X1, X2) -> U12(proper X1, proper X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        take(ok X1, ok X2) -> ok take(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        take(mark X1, X2) -> mark take(X1, X2)
        1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        take(X1, mark X2) -> mark take(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        tail ok X -> ok tail X
        2 + 1X >= 2 + 1X
        tail mark X -> mark tail X
        2 + 1X >= 2 + 1X
        sel(ok X1, ok X2) -> ok sel(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        sel(mark X1, X2) -> mark sel(X1, X2)
        1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        sel(X1, mark X2) -> mark sel(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        s ok X -> ok s X
        1 + 0X >= 2 + 0X
        s mark X -> mark s X
        1 + 0X >= 2 + 0X
        natsFrom ok X -> ok natsFrom X
        2 + 1X >= 2 + 1X
        natsFrom mark X -> mark natsFrom X
        2 + 1X >= 2 + 1X
        head ok X -> ok head X
        2 + 1X >= 2 + 1X
        head mark X -> mark head X
        2 + 1X >= 2 + 1X
        fst ok X -> ok fst X
        2 + 1X >= 2 + 1X
        fst mark X -> mark fst X
        2 + 1X >= 2 + 1X
        and(ok X1, ok X2) -> ok and(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        and(mark X1, X2) -> mark and(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        afterNth(mark X1, X2) -> mark afterNth(X1, X2)
        1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        afterNth(X1, mark X2) -> mark afterNth(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        snd ok X -> ok snd X
        2 + 1X >= 2 + 1X
        snd mark X -> mark snd X
        2 + 1X >= 2 + 1X
        cons(ok X1, ok X2) -> ok cons(X1, X2)
        1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
        cons(mark X1, X2) -> mark cons(X1, X2)
        1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
        pair(ok X1, ok X2) -> ok pair(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        pair(mark X1, X2) -> mark pair(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        pair(X1, mark X2) -> mark pair(X1, X2)
        1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
        2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
        U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
        2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
        active take(X1, X2) -> take(active X1, X2)
        2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        active take(X1, X2) -> take(X1, active X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        active take(N, XS) -> mark fst splitAt(N, XS)
        2 + 0N + 1XS >= 3 + 0N + 1XS
        active tail cons(N, XS) -> mark XS
        3 + 0N + 0XS >= 1 + 1XS
        active tail X -> tail active X
        2 + 1X >= 2 + 1X
        active sel(X1, X2) -> sel(active X1, X2)
        2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        active sel(X1, X2) -> sel(X1, active X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        active sel(N, XS) -> mark head afterNth(N, XS)
        2 + 0N + 1XS >= 3 + 0N + 1XS
        active s X -> s active X
        2 + 0X >= 1 + 0X
        active natsFrom X -> natsFrom active X
        2 + 1X >= 2 + 1X
        active natsFrom N -> mark cons(N, natsFrom s N)
        2 + 1N >= 2 + 0N
        active head cons(N, XS) -> mark N
        3 + 0N + 0XS >= 1 + 1N
        active head X -> head active X
        2 + 1X >= 2 + 1X
        active fst pair(X, Y) -> mark X
        3 + 1X + 0Y >= 1 + 1X
        active fst X -> fst active X
        2 + 1X >= 2 + 1X
        active and(tt(), X) -> mark X
        3 + 0X >= 1 + 1X
        active and(X1, X2) -> and(active X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        active afterNth(X1, X2) -> afterNth(active X1, X2)
        2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        active afterNth(X1, X2) -> afterNth(X1, active X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        active afterNth(N, XS) -> mark snd splitAt(N, XS)
        2 + 0N + 1XS >= 3 + 0N + 1XS
        active snd pair(X, Y) -> mark Y
        3 + 1X + 0Y >= 1 + 1Y
        active snd X -> snd active X
        2 + 1X >= 2 + 1X
        active cons(X1, X2) -> cons(active X1, X2)
        2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
        active pair(X1, X2) -> pair(active X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        active pair(X1, X2) -> pair(X1, active X2)
        2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
        3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
        2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
        active splitAt(0(), XS) -> mark pair(nil(), XS)
        2 + 1XS >= 3 + 0XS
        active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
        3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
        active splitAt(X1, X2) -> splitAt(active X1, X2)
        2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        active splitAt(X1, X2) -> splitAt(X1, active X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
        3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
        active U12(X1, X2) -> U12(active X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        splitAt(mark X1, X2) -> mark splitAt(X1, X2)
        1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        splitAt(X1, mark X2) -> mark splitAt(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        U12(ok X1, ok X2) -> ok U12(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        U12(mark X1, X2) -> mark U12(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      Qed
  
  
  
  
  
  SCC (2):
   Strict:
    {s# mark X -> s# X,
       s# ok X -> s# X}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = 0,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = 0,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 1,
     
     [s#](x0) = x0 + 1
    Strict:
     s# ok X -> s# X
     2 + 1X >= 1 + 1X
     s# mark X -> s# X
     2 + 1X >= 1 + 1X
    Weak:
     top ok X -> top active X
     0 + 0X >= 0 + 0X
     top mark X -> top proper X
     0 + 0X >= 0 + 0X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     2 >= 2
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 2 + 0N + 0XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 2 + 0N + 0XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 2 + 0N + 0XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     1 + 0XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     1 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed
 
 SCC (2):
  Strict:
   {natsFrom# mark X -> natsFrom# X,
      natsFrom# ok X -> natsFrom# X}
  Weak:
  {                U12(mark X1, X2) -> mark U12(X1, X2),
                  U12(ok X1, ok X2) -> ok U12(X1, X2),
               splitAt(X1, mark X2) -> mark splitAt(X1, X2),
               splitAt(mark X1, X2) -> mark splitAt(X1, X2),
              splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                 active U12(X1, X2) -> U12(active X1, X2),
        active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
             active splitAt(X1, X2) -> splitAt(X1, active X2),
             active splitAt(X1, X2) -> splitAt(active X1, X2),
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
            active splitAt(0(), XS) -> mark pair(nil(), XS),
         active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                active pair(X1, X2) -> pair(X1, active X2),
                active pair(X1, X2) -> pair(active X1, X2),
                active cons(X1, X2) -> cons(active X1, X2),
                       active snd X -> snd active X,
              active snd pair(X, Y) -> mark Y,
             active afterNth(N, XS) -> mark snd splitAt(N, XS),
            active afterNth(X1, X2) -> afterNth(X1, active X2),
            active afterNth(X1, X2) -> afterNth(active X1, X2),
                 active and(X1, X2) -> and(active X1, X2),
                active and(tt(), X) -> mark X,
                       active fst X -> fst active X,
              active fst pair(X, Y) -> mark X,
                      active head X -> head active X,
            active head cons(N, XS) -> mark N,
                  active natsFrom N -> mark cons(N, natsFrom s N),
                  active natsFrom X -> natsFrom active X,
                         active s X -> s active X,
                  active sel(N, XS) -> mark head afterNth(N, XS),
                 active sel(X1, X2) -> sel(X1, active X2),
                 active sel(X1, X2) -> sel(active X1, X2),
                      active tail X -> tail active X,
            active tail cons(N, XS) -> mark XS,
                 active take(N, XS) -> mark fst splitAt(N, XS),
                active take(X1, X2) -> take(X1, active X2),
                active take(X1, X2) -> take(active X1, X2),
           U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                  pair(X1, mark X2) -> mark pair(X1, X2),
                  pair(mark X1, X2) -> mark pair(X1, X2),
                 pair(ok X1, ok X2) -> ok pair(X1, X2),
                  cons(mark X1, X2) -> mark cons(X1, X2),
                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                         snd mark X -> mark snd X,
                           snd ok X -> ok snd X,
              afterNth(X1, mark X2) -> mark afterNth(X1, X2),
              afterNth(mark X1, X2) -> mark afterNth(X1, X2),
             afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                   and(mark X1, X2) -> mark and(X1, X2),
                  and(ok X1, ok X2) -> ok and(X1, X2),
                         fst mark X -> mark fst X,
                           fst ok X -> ok fst X,
                        head mark X -> mark head X,
                          head ok X -> ok head X,
                    natsFrom mark X -> mark natsFrom X,
                      natsFrom ok X -> ok natsFrom X,
                           s mark X -> mark s X,
                             s ok X -> ok s X,
                   sel(X1, mark X2) -> mark sel(X1, X2),
                   sel(mark X1, X2) -> mark sel(X1, X2),
                  sel(ok X1, ok X2) -> ok sel(X1, X2),
                        tail mark X -> mark tail X,
                          tail ok X -> ok tail X,
                  take(X1, mark X2) -> mark take(X1, X2),
                  take(mark X1, X2) -> mark take(X1, X2),
                 take(ok X1, ok X2) -> ok take(X1, X2),
                 proper U12(X1, X2) -> U12(proper X1, proper X2),
             proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
         proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                        proper tt() -> ok tt(),
                proper pair(X1, X2) -> pair(proper X1, proper X2),
                proper cons(X1, X2) -> cons(proper X1, proper X2),
                       proper snd X -> snd proper X,
            proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                 proper and(X1, X2) -> and(proper X1, proper X2),
                       proper fst X -> fst proper X,
                      proper head X -> head proper X,
                  proper natsFrom X -> natsFrom proper X,
                         proper s X -> s proper X,
                 proper sel(X1, X2) -> sel(proper X1, proper X2),
                       proper nil() -> ok nil(),
                         proper 0() -> ok 0(),
                      proper tail X -> tail proper X,
                proper take(X1, X2) -> take(proper X1, proper X2),
                         top mark X -> top proper X,
                           top ok X -> top active X}
  POLY:
   Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
   Interpretation:
    [U11](x0, x1, x2, x3) = x0 + 1,
    
    [U12](x0, x1) = x0 + 1,
    
    [splitAt](x0, x1) = 0,
    
    [pair](x0, x1) = x0 + 1,
    
    [cons](x0, x1) = 1,
    
    [afterNth](x0, x1) = x0 + 1,
    
    [and](x0, x1) = x0 + 1,
    
    [sel](x0, x1) = x0 + 1,
    
    [take](x0, x1) = x0 + 1,
    
    [mark](x0) = x0 + 1,
    
    [active](x0) = x0 + 1,
    
    [snd](x0) = x0 + 1,
    
    [fst](x0) = x0 + 1,
    
    [head](x0) = x0 + 1,
    
    [natsFrom](x0) = x0 + 1,
    
    [s](x0) = 1,
    
    [tail](x0) = x0 + 1,
    
    [proper](x0) = x0 + 1,
    
    [ok](x0) = x0 + 1,
    
    [top](x0) = 0,
    
    [tt] = 1,
    
    [nil] = 1,
    
    [0] = 1,
    
    [natsFrom#](x0) = x0 + 1
   Strict:
    natsFrom# ok X -> natsFrom# X
    2 + 1X >= 1 + 1X
    natsFrom# mark X -> natsFrom# X
    2 + 1X >= 1 + 1X
   Weak:
    top ok X -> top active X
    0 + 0X >= 0 + 0X
    top mark X -> top proper X
    0 + 0X >= 0 + 0X
    proper take(X1, X2) -> take(proper X1, proper X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    proper tail X -> tail proper X
    2 + 1X >= 2 + 1X
    proper 0() -> ok 0()
    2 >= 2
    proper nil() -> ok nil()
    2 >= 2
    proper sel(X1, X2) -> sel(proper X1, proper X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    proper s X -> s proper X
    2 + 0X >= 1 + 0X
    proper natsFrom X -> natsFrom proper X
    2 + 1X >= 2 + 1X
    proper head X -> head proper X
    2 + 1X >= 2 + 1X
    proper fst X -> fst proper X
    2 + 1X >= 2 + 1X
    proper and(X1, X2) -> and(proper X1, proper X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    proper snd X -> snd proper X
    2 + 1X >= 2 + 1X
    proper cons(X1, X2) -> cons(proper X1, proper X2)
    2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    proper pair(X1, X2) -> pair(proper X1, proper X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    proper tt() -> ok tt()
    2 >= 2
    proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
    1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
    proper U12(X1, X2) -> U12(proper X1, proper X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    take(ok X1, ok X2) -> ok take(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    take(mark X1, X2) -> mark take(X1, X2)
    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    take(X1, mark X2) -> mark take(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    tail ok X -> ok tail X
    2 + 1X >= 2 + 1X
    tail mark X -> mark tail X
    2 + 1X >= 2 + 1X
    sel(ok X1, ok X2) -> ok sel(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    sel(mark X1, X2) -> mark sel(X1, X2)
    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    sel(X1, mark X2) -> mark sel(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    s ok X -> ok s X
    1 + 0X >= 2 + 0X
    s mark X -> mark s X
    1 + 0X >= 2 + 0X
    natsFrom ok X -> ok natsFrom X
    2 + 1X >= 2 + 1X
    natsFrom mark X -> mark natsFrom X
    2 + 1X >= 2 + 1X
    head ok X -> ok head X
    2 + 1X >= 2 + 1X
    head mark X -> mark head X
    2 + 1X >= 2 + 1X
    fst ok X -> ok fst X
    2 + 1X >= 2 + 1X
    fst mark X -> mark fst X
    2 + 1X >= 2 + 1X
    and(ok X1, ok X2) -> ok and(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    and(mark X1, X2) -> mark and(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    afterNth(mark X1, X2) -> mark afterNth(X1, X2)
    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    afterNth(X1, mark X2) -> mark afterNth(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    snd ok X -> ok snd X
    2 + 1X >= 2 + 1X
    snd mark X -> mark snd X
    2 + 1X >= 2 + 1X
    cons(ok X1, ok X2) -> ok cons(X1, X2)
    1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
    cons(mark X1, X2) -> mark cons(X1, X2)
    1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
    pair(ok X1, ok X2) -> ok pair(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    pair(mark X1, X2) -> mark pair(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    pair(X1, mark X2) -> mark pair(X1, X2)
    1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    active take(X1, X2) -> take(active X1, X2)
    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    active take(X1, X2) -> take(X1, active X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    active take(N, XS) -> mark fst splitAt(N, XS)
    2 + 0N + 1XS >= 2 + 0N + 0XS
    active tail cons(N, XS) -> mark XS
    3 + 0N + 0XS >= 1 + 1XS
    active tail X -> tail active X
    2 + 1X >= 2 + 1X
    active sel(X1, X2) -> sel(active X1, X2)
    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    active sel(X1, X2) -> sel(X1, active X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    active sel(N, XS) -> mark head afterNth(N, XS)
    2 + 0N + 1XS >= 3 + 0N + 1XS
    active s X -> s active X
    2 + 0X >= 1 + 0X
    active natsFrom X -> natsFrom active X
    2 + 1X >= 2 + 1X
    active natsFrom N -> mark cons(N, natsFrom s N)
    2 + 1N >= 2 + 0N
    active head cons(N, XS) -> mark N
    3 + 0N + 0XS >= 1 + 1N
    active head X -> head active X
    2 + 1X >= 2 + 1X
    active fst pair(X, Y) -> mark X
    3 + 1X + 0Y >= 1 + 1X
    active fst X -> fst active X
    2 + 1X >= 2 + 1X
    active and(tt(), X) -> mark X
    3 + 0X >= 1 + 1X
    active and(X1, X2) -> and(active X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    active afterNth(X1, X2) -> afterNth(active X1, X2)
    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    active afterNth(X1, X2) -> afterNth(X1, active X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    active afterNth(N, XS) -> mark snd splitAt(N, XS)
    2 + 0N + 1XS >= 2 + 0N + 0XS
    active snd pair(X, Y) -> mark Y
    3 + 1X + 0Y >= 1 + 1Y
    active snd X -> snd active X
    2 + 1X >= 2 + 1X
    active cons(X1, X2) -> cons(active X1, X2)
    2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    active pair(X1, X2) -> pair(active X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    active pair(X1, X2) -> pair(X1, active X2)
    2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
    active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
    3 + 0N + 0XS + 0X >= 2 + 0N + 0XS + 0X
    active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    active splitAt(0(), XS) -> mark pair(nil(), XS)
    1 + 0XS >= 3 + 0XS
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
    1 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
    active splitAt(X1, X2) -> splitAt(active X1, X2)
    1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
    active splitAt(X1, X2) -> splitAt(X1, active X2)
    1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
    active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
    3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
    active U12(X1, X2) -> U12(active X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
    0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    splitAt(mark X1, X2) -> mark splitAt(X1, X2)
    0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    splitAt(X1, mark X2) -> mark splitAt(X1, X2)
    0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    U12(ok X1, ok X2) -> ok U12(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    U12(mark X1, X2) -> mark U12(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
  Qed
 
 
 SCC (2):
  Strict:
   {head# mark X -> head# X,
      head# ok X -> head# X}
  Weak:
  {                U12(mark X1, X2) -> mark U12(X1, X2),
                  U12(ok X1, ok X2) -> ok U12(X1, X2),
               splitAt(X1, mark X2) -> mark splitAt(X1, X2),
               splitAt(mark X1, X2) -> mark splitAt(X1, X2),
              splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                 active U12(X1, X2) -> U12(active X1, X2),
        active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
             active splitAt(X1, X2) -> splitAt(X1, active X2),
             active splitAt(X1, X2) -> splitAt(active X1, X2),
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
            active splitAt(0(), XS) -> mark pair(nil(), XS),
         active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                active pair(X1, X2) -> pair(X1, active X2),
                active pair(X1, X2) -> pair(active X1, X2),
                active cons(X1, X2) -> cons(active X1, X2),
                       active snd X -> snd active X,
              active snd pair(X, Y) -> mark Y,
             active afterNth(N, XS) -> mark snd splitAt(N, XS),
            active afterNth(X1, X2) -> afterNth(X1, active X2),
            active afterNth(X1, X2) -> afterNth(active X1, X2),
                 active and(X1, X2) -> and(active X1, X2),
                active and(tt(), X) -> mark X,
                       active fst X -> fst active X,
              active fst pair(X, Y) -> mark X,
                      active head X -> head active X,
            active head cons(N, XS) -> mark N,
                  active natsFrom N -> mark cons(N, natsFrom s N),
                  active natsFrom X -> natsFrom active X,
                         active s X -> s active X,
                  active sel(N, XS) -> mark head afterNth(N, XS),
                 active sel(X1, X2) -> sel(X1, active X2),
                 active sel(X1, X2) -> sel(active X1, X2),
                      active tail X -> tail active X,
            active tail cons(N, XS) -> mark XS,
                 active take(N, XS) -> mark fst splitAt(N, XS),
                active take(X1, X2) -> take(X1, active X2),
                active take(X1, X2) -> take(active X1, X2),
           U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                  pair(X1, mark X2) -> mark pair(X1, X2),
                  pair(mark X1, X2) -> mark pair(X1, X2),
                 pair(ok X1, ok X2) -> ok pair(X1, X2),
                  cons(mark X1, X2) -> mark cons(X1, X2),
                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                         snd mark X -> mark snd X,
                           snd ok X -> ok snd X,
              afterNth(X1, mark X2) -> mark afterNth(X1, X2),
              afterNth(mark X1, X2) -> mark afterNth(X1, X2),
             afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                   and(mark X1, X2) -> mark and(X1, X2),
                  and(ok X1, ok X2) -> ok and(X1, X2),
                         fst mark X -> mark fst X,
                           fst ok X -> ok fst X,
                        head mark X -> mark head X,
                          head ok X -> ok head X,
                    natsFrom mark X -> mark natsFrom X,
                      natsFrom ok X -> ok natsFrom X,
                           s mark X -> mark s X,
                             s ok X -> ok s X,
                   sel(X1, mark X2) -> mark sel(X1, X2),
                   sel(mark X1, X2) -> mark sel(X1, X2),
                  sel(ok X1, ok X2) -> ok sel(X1, X2),
                        tail mark X -> mark tail X,
                          tail ok X -> ok tail X,
                  take(X1, mark X2) -> mark take(X1, X2),
                  take(mark X1, X2) -> mark take(X1, X2),
                 take(ok X1, ok X2) -> ok take(X1, X2),
                 proper U12(X1, X2) -> U12(proper X1, proper X2),
             proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
         proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                        proper tt() -> ok tt(),
                proper pair(X1, X2) -> pair(proper X1, proper X2),
                proper cons(X1, X2) -> cons(proper X1, proper X2),
                       proper snd X -> snd proper X,
            proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                 proper and(X1, X2) -> and(proper X1, proper X2),
                       proper fst X -> fst proper X,
                      proper head X -> head proper X,
                  proper natsFrom X -> natsFrom proper X,
                         proper s X -> s proper X,
                 proper sel(X1, X2) -> sel(proper X1, proper X2),
                       proper nil() -> ok nil(),
                         proper 0() -> ok 0(),
                      proper tail X -> tail proper X,
                proper take(X1, X2) -> take(proper X1, proper X2),
                         top mark X -> top proper X,
                           top ok X -> top active X}
  POLY:
   Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
   Interpretation:
    [U11](x0, x1, x2, x3) = x0 + 1,
    
    [U12](x0, x1) = x0 + 1,
    
    [splitAt](x0, x1) = 0,
    
    [pair](x0, x1) = x0 + 1,
    
    [cons](x0, x1) = 1,
    
    [afterNth](x0, x1) = x0 + 1,
    
    [and](x0, x1) = x0 + 1,
    
    [sel](x0, x1) = x0 + 1,
    
    [take](x0, x1) = x0 + 1,
    
    [mark](x0) = x0 + 1,
    
    [active](x0) = x0 + 1,
    
    [snd](x0) = x0 + 1,
    
    [fst](x0) = x0 + 1,
    
    [head](x0) = x0 + 1,
    
    [natsFrom](x0) = x0 + 1,
    
    [s](x0) = 1,
    
    [tail](x0) = x0 + 1,
    
    [proper](x0) = x0 + 1,
    
    [ok](x0) = x0 + 1,
    
    [top](x0) = 0,
    
    [tt] = 1,
    
    [nil] = 1,
    
    [0] = 1,
    
    [head#](x0) = x0 + 1
   Strict:
    head# ok X -> head# X
    2 + 1X >= 1 + 1X
    head# mark X -> head# X
    2 + 1X >= 1 + 1X
   Weak:
    top ok X -> top active X
    0 + 0X >= 0 + 0X
    top mark X -> top proper X
    0 + 0X >= 0 + 0X
    proper take(X1, X2) -> take(proper X1, proper X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    proper tail X -> tail proper X
    2 + 1X >= 2 + 1X
    proper 0() -> ok 0()
    2 >= 2
    proper nil() -> ok nil()
    2 >= 2
    proper sel(X1, X2) -> sel(proper X1, proper X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    proper s X -> s proper X
    2 + 0X >= 1 + 0X
    proper natsFrom X -> natsFrom proper X
    2 + 1X >= 2 + 1X
    proper head X -> head proper X
    2 + 1X >= 2 + 1X
    proper fst X -> fst proper X
    2 + 1X >= 2 + 1X
    proper and(X1, X2) -> and(proper X1, proper X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    proper snd X -> snd proper X
    2 + 1X >= 2 + 1X
    proper cons(X1, X2) -> cons(proper X1, proper X2)
    2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    proper pair(X1, X2) -> pair(proper X1, proper X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    proper tt() -> ok tt()
    2 >= 2
    proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
    1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
    proper U12(X1, X2) -> U12(proper X1, proper X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    take(ok X1, ok X2) -> ok take(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    take(mark X1, X2) -> mark take(X1, X2)
    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    take(X1, mark X2) -> mark take(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    tail ok X -> ok tail X
    2 + 1X >= 2 + 1X
    tail mark X -> mark tail X
    2 + 1X >= 2 + 1X
    sel(ok X1, ok X2) -> ok sel(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    sel(mark X1, X2) -> mark sel(X1, X2)
    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    sel(X1, mark X2) -> mark sel(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    s ok X -> ok s X
    1 + 0X >= 2 + 0X
    s mark X -> mark s X
    1 + 0X >= 2 + 0X
    natsFrom ok X -> ok natsFrom X
    2 + 1X >= 2 + 1X
    natsFrom mark X -> mark natsFrom X
    2 + 1X >= 2 + 1X
    head ok X -> ok head X
    2 + 1X >= 2 + 1X
    head mark X -> mark head X
    2 + 1X >= 2 + 1X
    fst ok X -> ok fst X
    2 + 1X >= 2 + 1X
    fst mark X -> mark fst X
    2 + 1X >= 2 + 1X
    and(ok X1, ok X2) -> ok and(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    and(mark X1, X2) -> mark and(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    afterNth(mark X1, X2) -> mark afterNth(X1, X2)
    1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    afterNth(X1, mark X2) -> mark afterNth(X1, X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    snd ok X -> ok snd X
    2 + 1X >= 2 + 1X
    snd mark X -> mark snd X
    2 + 1X >= 2 + 1X
    cons(ok X1, ok X2) -> ok cons(X1, X2)
    1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
    cons(mark X1, X2) -> mark cons(X1, X2)
    1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
    pair(ok X1, ok X2) -> ok pair(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    pair(mark X1, X2) -> mark pair(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    pair(X1, mark X2) -> mark pair(X1, X2)
    1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    active take(X1, X2) -> take(active X1, X2)
    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    active take(X1, X2) -> take(X1, active X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    active take(N, XS) -> mark fst splitAt(N, XS)
    2 + 0N + 1XS >= 2 + 0N + 0XS
    active tail cons(N, XS) -> mark XS
    3 + 0N + 0XS >= 1 + 1XS
    active tail X -> tail active X
    2 + 1X >= 2 + 1X
    active sel(X1, X2) -> sel(active X1, X2)
    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    active sel(X1, X2) -> sel(X1, active X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    active sel(N, XS) -> mark head afterNth(N, XS)
    2 + 0N + 1XS >= 3 + 0N + 1XS
    active s X -> s active X
    2 + 0X >= 1 + 0X
    active natsFrom X -> natsFrom active X
    2 + 1X >= 2 + 1X
    active natsFrom N -> mark cons(N, natsFrom s N)
    2 + 1N >= 2 + 0N
    active head cons(N, XS) -> mark N
    3 + 0N + 0XS >= 1 + 1N
    active head X -> head active X
    2 + 1X >= 2 + 1X
    active fst pair(X, Y) -> mark X
    3 + 1X + 0Y >= 1 + 1X
    active fst X -> fst active X
    2 + 1X >= 2 + 1X
    active and(tt(), X) -> mark X
    3 + 0X >= 1 + 1X
    active and(X1, X2) -> and(active X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    active afterNth(X1, X2) -> afterNth(active X1, X2)
    2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    active afterNth(X1, X2) -> afterNth(X1, active X2)
    2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
    active afterNth(N, XS) -> mark snd splitAt(N, XS)
    2 + 0N + 1XS >= 2 + 0N + 0XS
    active snd pair(X, Y) -> mark Y
    3 + 1X + 0Y >= 1 + 1Y
    active snd X -> snd active X
    2 + 1X >= 2 + 1X
    active cons(X1, X2) -> cons(active X1, X2)
    2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    active pair(X1, X2) -> pair(active X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    active pair(X1, X2) -> pair(X1, active X2)
    2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
    active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
    3 + 0N + 0XS + 0X >= 2 + 0N + 0XS + 0X
    active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
    2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
    active splitAt(0(), XS) -> mark pair(nil(), XS)
    1 + 0XS >= 3 + 0XS
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
    1 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
    active splitAt(X1, X2) -> splitAt(active X1, X2)
    1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
    active splitAt(X1, X2) -> splitAt(X1, active X2)
    1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
    active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
    3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
    active U12(X1, X2) -> U12(active X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
    0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    splitAt(mark X1, X2) -> mark splitAt(X1, X2)
    0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    splitAt(X1, mark X2) -> mark splitAt(X1, X2)
    0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
    U12(ok X1, ok X2) -> ok U12(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    U12(mark X1, X2) -> mark U12(X1, X2)
    2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
  Qed

SCC (2):
 Strict:
  {fst# mark X -> fst# X,
     fst# ok X -> fst# X}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = x0 + 1,
   
   [splitAt](x0, x1) = 0,
   
   [pair](x0, x1) = x0 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = x0 + 1,
   
   [and](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [take](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [snd](x0) = x0 + 1,
   
   [fst](x0) = x0 + 1,
   
   [head](x0) = x0 + 1,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = x0 + 1,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [fst#](x0) = x0 + 1
  Strict:
   fst# ok X -> fst# X
   2 + 1X >= 1 + 1X
   fst# mark X -> fst# X
   2 + 1X >= 1 + 1X
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper tail X -> tail proper X
   2 + 1X >= 2 + 1X
   proper 0() -> ok 0()
   2 >= 2
   proper nil() -> ok nil()
   2 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper s X -> s proper X
   2 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   2 + 1X >= 2 + 1X
   proper head X -> head proper X
   2 + 1X >= 2 + 1X
   proper fst X -> fst proper X
   2 + 1X >= 2 + 1X
   proper and(X1, X2) -> and(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper snd X -> snd proper X
   2 + 1X >= 2 + 1X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper tt() -> ok tt()
   2 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(mark X1, X2) -> mark take(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(X1, mark X2) -> mark take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   2 + 1X >= 2 + 1X
   head mark X -> mark head X
   2 + 1X >= 2 + 1X
   fst ok X -> ok fst X
   2 + 1X >= 2 + 1X
   fst mark X -> mark fst X
   2 + 1X >= 2 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   snd ok X -> ok snd X
   2 + 1X >= 2 + 1X
   snd mark X -> mark snd X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active take(X1, X2) -> take(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   2 + 0N + 1XS >= 2 + 0N + 0XS
   active tail cons(N, XS) -> mark XS
   3 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   2 + 1X >= 2 + 1X
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active s X -> s active X
   2 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   2 + 1X >= 2 + 1X
   active natsFrom N -> mark cons(N, natsFrom s N)
   2 + 1N >= 2 + 0N
   active head cons(N, XS) -> mark N
   3 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   2 + 1X >= 2 + 1X
   active fst pair(X, Y) -> mark X
   3 + 1X + 0Y >= 1 + 1X
   active fst X -> fst active X
   2 + 1X >= 2 + 1X
   active and(tt(), X) -> mark X
   3 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   2 + 0N + 1XS >= 2 + 0N + 0XS
   active snd pair(X, Y) -> mark Y
   3 + 1X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active pair(X1, X2) -> pair(X1, active X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   3 + 0N + 0XS + 0X >= 2 + 0N + 0XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   1 + 0XS >= 3 + 0XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   1 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
   active U12(X1, X2) -> U12(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 Qed

SCC (2):
 Strict:
  { and#(mark X1, X2) -> and#(X1, X2),
   and#(ok X1, ok X2) -> and#(X1, X2)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = x0 + 1,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = x0 + 1,
   
   [and](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [take](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [snd](x0) = x0 + 1,
   
   [fst](x0) = x0 + 1,
   
   [head](x0) = x0 + 1,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = x0 + 1,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [and#](x0, x1) = x0
  Strict:
   and#(ok X1, ok X2) -> and#(X1, X2)
   1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
   and#(mark X1, X2) -> and#(X1, X2)
   0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper tail X -> tail proper X
   2 + 1X >= 2 + 1X
   proper 0() -> ok 0()
   2 >= 2
   proper nil() -> ok nil()
   2 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper s X -> s proper X
   2 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   2 + 1X >= 2 + 1X
   proper head X -> head proper X
   2 + 1X >= 2 + 1X
   proper fst X -> fst proper X
   2 + 1X >= 2 + 1X
   proper and(X1, X2) -> and(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper snd X -> snd proper X
   2 + 1X >= 2 + 1X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper tt() -> ok tt()
   2 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(mark X1, X2) -> mark take(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(X1, mark X2) -> mark take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   2 + 1X >= 2 + 1X
   head mark X -> mark head X
   2 + 1X >= 2 + 1X
   fst ok X -> ok fst X
   2 + 1X >= 2 + 1X
   fst mark X -> mark fst X
   2 + 1X >= 2 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   snd ok X -> ok snd X
   2 + 1X >= 2 + 1X
   snd mark X -> mark snd X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active take(X1, X2) -> take(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   3 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   2 + 1X >= 2 + 1X
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active s X -> s active X
   2 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   2 + 1X >= 2 + 1X
   active natsFrom N -> mark cons(N, natsFrom s N)
   2 + 1N >= 2 + 0N
   active head cons(N, XS) -> mark N
   3 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   2 + 1X >= 2 + 1X
   active fst pair(X, Y) -> mark X
   3 + 1X + 0Y >= 1 + 1X
   active fst X -> fst active X
   2 + 1X >= 2 + 1X
   active and(tt(), X) -> mark X
   3 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active snd pair(X, Y) -> mark Y
   3 + 1X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active pair(X1, X2) -> pair(X1, active X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   2 + 1XS >= 3 + 0XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
   active U12(X1, X2) -> U12(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {and#(mark X1, X2) -> and#(X1, X2)}
  
  SCC (1):
   Strict:
    {and#(mark X1, X2) -> and#(X1, X2)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [and#](x0, x1) = x0 + 1
    Strict:
     and#(mark X1, X2) -> and#(X1, X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed


SCC (3):
 Strict:
  { afterNth#(X1, mark X2) -> afterNth#(X1, X2),
    afterNth#(mark X1, X2) -> afterNth#(X1, X2),
   afterNth#(ok X1, ok X2) -> afterNth#(X1, X2)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = 0,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + x1 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = 0,
   
   [and](x0, x1) = 0,
   
   [sel](x0, x1) = 0,
   
   [take](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = 0,
   
   [snd](x0) = 0,
   
   [fst](x0) = x0,
   
   [head](x0) = 0,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [afterNth#](x0, x1) = x0 + 1
  Strict:
   afterNth#(ok X1, ok X2) -> afterNth#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   afterNth#(mark X1, X2) -> afterNth#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   afterNth#(X1, mark X2) -> afterNth#(X1, X2)
   1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper tail X -> tail proper X
   0 + 0X >= 1 + 0X
   proper 0() -> ok 0()
   0 >= 2
   proper nil() -> ok nil()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   0 + 0X >= 1 + 0X
   proper head X -> head proper X
   0 + 0X >= 0 + 0X
   proper fst X -> fst proper X
   0 + 0X >= 0 + 0X
   proper and(X1, X2) -> and(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper snd X -> snd proper X
   0 + 0X >= 0 + 0X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper tt() -> ok tt()
   0 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   take(mark X1, X2) -> mark take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   take(X1, mark X2) -> mark take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   0 + 0X >= 1 + 0X
   head mark X -> mark head X
   0 + 0X >= 1 + 0X
   fst ok X -> ok fst X
   1 + 1X >= 1 + 1X
   fst mark X -> mark fst X
   1 + 1X >= 1 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   snd ok X -> ok snd X
   0 + 0X >= 1 + 0X
   snd mark X -> mark snd X
   0 + 0X >= 1 + 0X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active take(X1, X2) -> take(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   0 + 0N + 0XS >= 2 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   0 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   0 + 0X >= 1 + 0X
   active sel(X1, X2) -> sel(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(X1, X2) -> sel(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   0 + 0N + 0XS >= 1 + 0N + 0XS
   active s X -> s active X
   0 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   0 + 0X >= 1 + 0X
   active natsFrom N -> mark cons(N, natsFrom s N)
   0 + 0N >= 2 + 0N
   active head cons(N, XS) -> mark N
   0 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   0 + 0X >= 0 + 0X
   active fst pair(X, Y) -> mark X
   0 + 0X + 0Y >= 1 + 1X
   active fst X -> fst active X
   0 + 0X >= 0 + 0X
   active and(tt(), X) -> mark X
   0 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   0 + 0N + 0XS >= 1 + 0N + 0XS
   active snd pair(X, Y) -> mark Y
   0 + 0X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   0 + 0X >= 0 + 0X
   active cons(X1, X2) -> cons(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active pair(X1, X2) -> pair(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   0 + 0XS >= 3 + 1XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   0 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   0 + 0X + 0YS + 0ZS >= 3 + 0X + 0YS + 1ZS
   active U12(X1, X2) -> U12(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
 SCCS (1):
  Scc:
   {afterNth#(X1, mark X2) -> afterNth#(X1, X2)}
  
  SCC (1):
   Strict:
    {afterNth#(X1, mark X2) -> afterNth#(X1, X2)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [afterNth#](x0, x1) = x0 + 1
    Strict:
     afterNth#(X1, mark X2) -> afterNth#(X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed



SCC (2):
 Strict:
  {snd# mark X -> snd# X,
     snd# ok X -> snd# X}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = x0 + 1,
   
   [splitAt](x0, x1) = 0,
   
   [pair](x0, x1) = x0 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = x0 + 1,
   
   [and](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [take](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [snd](x0) = x0 + 1,
   
   [fst](x0) = x0 + 1,
   
   [head](x0) = x0 + 1,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = x0 + 1,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [snd#](x0) = x0 + 1
  Strict:
   snd# ok X -> snd# X
   2 + 1X >= 1 + 1X
   snd# mark X -> snd# X
   2 + 1X >= 1 + 1X
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper tail X -> tail proper X
   2 + 1X >= 2 + 1X
   proper 0() -> ok 0()
   2 >= 2
   proper nil() -> ok nil()
   2 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper s X -> s proper X
   2 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   2 + 1X >= 2 + 1X
   proper head X -> head proper X
   2 + 1X >= 2 + 1X
   proper fst X -> fst proper X
   2 + 1X >= 2 + 1X
   proper and(X1, X2) -> and(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper snd X -> snd proper X
   2 + 1X >= 2 + 1X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper tt() -> ok tt()
   2 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(mark X1, X2) -> mark take(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(X1, mark X2) -> mark take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   2 + 1X >= 2 + 1X
   head mark X -> mark head X
   2 + 1X >= 2 + 1X
   fst ok X -> ok fst X
   2 + 1X >= 2 + 1X
   fst mark X -> mark fst X
   2 + 1X >= 2 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   snd ok X -> ok snd X
   2 + 1X >= 2 + 1X
   snd mark X -> mark snd X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active take(X1, X2) -> take(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   2 + 0N + 1XS >= 2 + 0N + 0XS
   active tail cons(N, XS) -> mark XS
   3 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   2 + 1X >= 2 + 1X
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active s X -> s active X
   2 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   2 + 1X >= 2 + 1X
   active natsFrom N -> mark cons(N, natsFrom s N)
   2 + 1N >= 2 + 0N
   active head cons(N, XS) -> mark N
   3 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   2 + 1X >= 2 + 1X
   active fst pair(X, Y) -> mark X
   3 + 1X + 0Y >= 1 + 1X
   active fst X -> fst active X
   2 + 1X >= 2 + 1X
   active and(tt(), X) -> mark X
   3 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   2 + 0N + 1XS >= 2 + 0N + 0XS
   active snd pair(X, Y) -> mark Y
   3 + 1X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active pair(X1, X2) -> pair(X1, active X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   3 + 0N + 0XS + 0X >= 2 + 0N + 0XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   1 + 0XS >= 3 + 0XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   1 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
   active U12(X1, X2) -> U12(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 Qed






SCC (2):
 Strict:
  {       U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
   U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = x0 + 1,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = x0 + 1,
   
   [and](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [take](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [snd](x0) = x0 + 1,
   
   [fst](x0) = x0 + 1,
   
   [head](x0) = x0 + 1,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = 1,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [U11#](x0, x1, x2, x3) = x0
  Strict:
   U11#(ok X1, ok X2, ok X3, ok X4) -> U11#(X1, X2, X3, X4)
   1 + 0X1 + 0X2 + 0X3 + 1X4 >= 0 + 0X1 + 0X2 + 0X3 + 1X4
   U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4)
   0 + 0X1 + 0X2 + 0X3 + 1X4 >= 0 + 0X1 + 0X2 + 0X3 + 1X4
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   proper tail X -> tail proper X
   1 + 0X >= 2 + 0X
   proper 0() -> ok 0()
   1 >= 2
   proper nil() -> ok nil()
   1 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   proper s X -> s proper X
   1 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   1 + 0X >= 2 + 0X
   proper head X -> head proper X
   1 + 0X >= 2 + 0X
   proper fst X -> fst proper X
   1 + 0X >= 2 + 0X
   proper and(X1, X2) -> and(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   proper snd X -> snd proper X
   1 + 0X >= 2 + 0X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   proper tt() -> ok tt()
   1 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   1 + 0X1 + 0X2 + 0X3 + 0X4 >= 2 + 0X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(mark X1, X2) -> mark take(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(X1, mark X2) -> mark take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   2 + 1X >= 2 + 1X
   head mark X -> mark head X
   2 + 1X >= 2 + 1X
   fst ok X -> ok fst X
   2 + 1X >= 2 + 1X
   fst mark X -> mark fst X
   2 + 1X >= 2 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   snd ok X -> ok snd X
   2 + 1X >= 2 + 1X
   snd mark X -> mark snd X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active take(X1, X2) -> take(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   3 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   2 + 1X >= 2 + 1X
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active s X -> s active X
   2 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   2 + 1X >= 2 + 1X
   active natsFrom N -> mark cons(N, natsFrom s N)
   2 + 1N >= 2 + 0N
   active head cons(N, XS) -> mark N
   3 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   2 + 1X >= 2 + 1X
   active fst pair(X, Y) -> mark X
   3 + 1X + 0Y >= 1 + 1X
   active fst X -> fst active X
   2 + 1X >= 2 + 1X
   active and(tt(), X) -> mark X
   3 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active snd pair(X, Y) -> mark Y
   3 + 1X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active pair(X1, X2) -> pair(X1, active X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   2 + 1XS >= 3 + 0XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
   active U12(X1, X2) -> U12(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4)}
  
  SCC (1):
   Strict:
    {U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [U11#](x0, x1, x2, x3) = x0 + 1
    Strict:
     U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 1 + 1X1 + 0X2 + 0X3 + 0X4
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed




SCC (3):
 Strict:
  { splitAt#(X1, mark X2) -> splitAt#(X1, X2),
    splitAt#(mark X1, X2) -> splitAt#(X1, X2),
   splitAt#(ok X1, ok X2) -> splitAt#(X1, X2)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = 0,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + x1 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = 0,
   
   [and](x0, x1) = 0,
   
   [sel](x0, x1) = 0,
   
   [take](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = 0,
   
   [snd](x0) = 0,
   
   [fst](x0) = x0,
   
   [head](x0) = 0,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [splitAt#](x0, x1) = x0 + 1
  Strict:
   splitAt#(ok X1, ok X2) -> splitAt#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   splitAt#(mark X1, X2) -> splitAt#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   splitAt#(X1, mark X2) -> splitAt#(X1, X2)
   1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper tail X -> tail proper X
   0 + 0X >= 1 + 0X
   proper 0() -> ok 0()
   0 >= 2
   proper nil() -> ok nil()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   0 + 0X >= 1 + 0X
   proper head X -> head proper X
   0 + 0X >= 0 + 0X
   proper fst X -> fst proper X
   0 + 0X >= 0 + 0X
   proper and(X1, X2) -> and(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper snd X -> snd proper X
   0 + 0X >= 0 + 0X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper tt() -> ok tt()
   0 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   take(mark X1, X2) -> mark take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   take(X1, mark X2) -> mark take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   0 + 0X >= 1 + 0X
   head mark X -> mark head X
   0 + 0X >= 1 + 0X
   fst ok X -> ok fst X
   1 + 1X >= 1 + 1X
   fst mark X -> mark fst X
   1 + 1X >= 1 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   snd ok X -> ok snd X
   0 + 0X >= 1 + 0X
   snd mark X -> mark snd X
   0 + 0X >= 1 + 0X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active take(X1, X2) -> take(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   0 + 0N + 0XS >= 2 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   0 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   0 + 0X >= 1 + 0X
   active sel(X1, X2) -> sel(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(X1, X2) -> sel(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   0 + 0N + 0XS >= 1 + 0N + 0XS
   active s X -> s active X
   0 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   0 + 0X >= 1 + 0X
   active natsFrom N -> mark cons(N, natsFrom s N)
   0 + 0N >= 2 + 0N
   active head cons(N, XS) -> mark N
   0 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   0 + 0X >= 0 + 0X
   active fst pair(X, Y) -> mark X
   0 + 0X + 0Y >= 1 + 1X
   active fst X -> fst active X
   0 + 0X >= 0 + 0X
   active and(tt(), X) -> mark X
   0 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   0 + 0N + 0XS >= 1 + 0N + 0XS
   active snd pair(X, Y) -> mark Y
   0 + 0X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   0 + 0X >= 0 + 0X
   active cons(X1, X2) -> cons(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active pair(X1, X2) -> pair(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   0 + 0XS >= 3 + 1XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   0 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   0 + 0X + 0YS + 0ZS >= 3 + 0X + 0YS + 1ZS
   active U12(X1, X2) -> U12(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
 SCCS (1):
  Scc:
   {splitAt#(X1, mark X2) -> splitAt#(X1, X2)}
  
  SCC (1):
   Strict:
    {splitAt#(X1, mark X2) -> splitAt#(X1, X2)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [splitAt#](x0, x1) = x0 + 1
    Strict:
     splitAt#(X1, mark X2) -> splitAt#(X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed

SCC (2):
 Strict:
  { cons#(mark X1, X2) -> cons#(X1, X2),
   cons#(ok X1, ok X2) -> cons#(X1, X2)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = x0 + 1,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = x0 + 1,
   
   [and](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [take](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [snd](x0) = x0 + 1,
   
   [fst](x0) = x0 + 1,
   
   [head](x0) = x0 + 1,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = x0 + 1,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [cons#](x0, x1) = x0
  Strict:
   cons#(ok X1, ok X2) -> cons#(X1, X2)
   1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
   cons#(mark X1, X2) -> cons#(X1, X2)
   0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper tail X -> tail proper X
   2 + 1X >= 2 + 1X
   proper 0() -> ok 0()
   2 >= 2
   proper nil() -> ok nil()
   2 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper s X -> s proper X
   2 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   2 + 1X >= 2 + 1X
   proper head X -> head proper X
   2 + 1X >= 2 + 1X
   proper fst X -> fst proper X
   2 + 1X >= 2 + 1X
   proper and(X1, X2) -> and(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper snd X -> snd proper X
   2 + 1X >= 2 + 1X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper tt() -> ok tt()
   2 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(mark X1, X2) -> mark take(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(X1, mark X2) -> mark take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   2 + 1X >= 2 + 1X
   head mark X -> mark head X
   2 + 1X >= 2 + 1X
   fst ok X -> ok fst X
   2 + 1X >= 2 + 1X
   fst mark X -> mark fst X
   2 + 1X >= 2 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   snd ok X -> ok snd X
   2 + 1X >= 2 + 1X
   snd mark X -> mark snd X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active take(X1, X2) -> take(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   3 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   2 + 1X >= 2 + 1X
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active s X -> s active X
   2 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   2 + 1X >= 2 + 1X
   active natsFrom N -> mark cons(N, natsFrom s N)
   2 + 1N >= 2 + 0N
   active head cons(N, XS) -> mark N
   3 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   2 + 1X >= 2 + 1X
   active fst pair(X, Y) -> mark X
   3 + 1X + 0Y >= 1 + 1X
   active fst X -> fst active X
   2 + 1X >= 2 + 1X
   active and(tt(), X) -> mark X
   3 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active snd pair(X, Y) -> mark Y
   3 + 1X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active pair(X1, X2) -> pair(X1, active X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   2 + 1XS >= 3 + 0XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
   active U12(X1, X2) -> U12(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {cons#(mark X1, X2) -> cons#(X1, X2)}
  
  SCC (1):
   Strict:
    {cons#(mark X1, X2) -> cons#(X1, X2)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [cons#](x0, x1) = x0 + 1
    Strict:
     cons#(mark X1, X2) -> cons#(X1, X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed

SCC (3):
 Strict:
  { pair#(X1, mark X2) -> pair#(X1, X2),
    pair#(mark X1, X2) -> pair#(X1, X2),
   pair#(ok X1, ok X2) -> pair#(X1, X2)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = 0,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + x1 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = 0,
   
   [and](x0, x1) = 0,
   
   [sel](x0, x1) = 0,
   
   [take](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = 0,
   
   [snd](x0) = 0,
   
   [fst](x0) = x0,
   
   [head](x0) = 0,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [pair#](x0, x1) = x0 + 1
  Strict:
   pair#(ok X1, ok X2) -> pair#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   pair#(mark X1, X2) -> pair#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   pair#(X1, mark X2) -> pair#(X1, X2)
   1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper tail X -> tail proper X
   0 + 0X >= 1 + 0X
   proper 0() -> ok 0()
   0 >= 2
   proper nil() -> ok nil()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   0 + 0X >= 1 + 0X
   proper head X -> head proper X
   0 + 0X >= 0 + 0X
   proper fst X -> fst proper X
   0 + 0X >= 0 + 0X
   proper and(X1, X2) -> and(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper snd X -> snd proper X
   0 + 0X >= 0 + 0X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper tt() -> ok tt()
   0 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   take(mark X1, X2) -> mark take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   take(X1, mark X2) -> mark take(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   0 + 0X >= 1 + 0X
   head mark X -> mark head X
   0 + 0X >= 1 + 0X
   fst ok X -> ok fst X
   1 + 1X >= 1 + 1X
   fst mark X -> mark fst X
   1 + 1X >= 1 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   snd ok X -> ok snd X
   0 + 0X >= 1 + 0X
   snd mark X -> mark snd X
   0 + 0X >= 1 + 0X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active take(X1, X2) -> take(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   0 + 0N + 0XS >= 2 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   0 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   0 + 0X >= 1 + 0X
   active sel(X1, X2) -> sel(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(X1, X2) -> sel(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   0 + 0N + 0XS >= 1 + 0N + 0XS
   active s X -> s active X
   0 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   0 + 0X >= 1 + 0X
   active natsFrom N -> mark cons(N, natsFrom s N)
   0 + 0N >= 2 + 0N
   active head cons(N, XS) -> mark N
   0 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   0 + 0X >= 0 + 0X
   active fst pair(X, Y) -> mark X
   0 + 0X + 0Y >= 1 + 1X
   active fst X -> fst active X
   0 + 0X >= 0 + 0X
   active and(tt(), X) -> mark X
   0 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   0 + 0N + 0XS >= 1 + 0N + 0XS
   active snd pair(X, Y) -> mark Y
   0 + 0X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   0 + 0X >= 0 + 0X
   active cons(X1, X2) -> cons(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active pair(X1, X2) -> pair(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   0 + 0N + 0XS + 0X >= 1 + 0N + 0XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   0 + 0X1 + 0X2 + 0X3 + 0X4 >= 1 + 0X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   0 + 0XS >= 3 + 1XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   0 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   0 + 0X + 0YS + 0ZS >= 3 + 0X + 0YS + 1ZS
   active U12(X1, X2) -> U12(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
 SCCS (1):
  Scc:
   {pair#(X1, mark X2) -> pair#(X1, X2)}
  
  SCC (1):
   Strict:
    {pair#(X1, mark X2) -> pair#(X1, X2)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [pair#](x0, x1) = x0 + 1
    Strict:
     pair#(X1, mark X2) -> pair#(X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed

SCC (2):
 Strict:
  { U12#(mark X1, X2) -> U12#(X1, X2),
   U12#(ok X1, ok X2) -> U12#(X1, X2)}
 Weak:
 {                U12(mark X1, X2) -> mark U12(X1, X2),
                 U12(ok X1, ok X2) -> ok U12(X1, X2),
              splitAt(X1, mark X2) -> mark splitAt(X1, X2),
              splitAt(mark X1, X2) -> mark splitAt(X1, X2),
             splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                active U12(X1, X2) -> U12(active X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
            active splitAt(X1, X2) -> splitAt(X1, active X2),
            active splitAt(X1, X2) -> splitAt(active X1, X2),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
               active pair(X1, X2) -> pair(X1, active X2),
               active pair(X1, X2) -> pair(active X1, X2),
               active cons(X1, X2) -> cons(active X1, X2),
                      active snd X -> snd active X,
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
           active afterNth(X1, X2) -> afterNth(X1, active X2),
           active afterNth(X1, X2) -> afterNth(active X1, X2),
                active and(X1, X2) -> and(active X1, X2),
               active and(tt(), X) -> mark X,
                      active fst X -> fst active X,
             active fst pair(X, Y) -> mark X,
                     active head X -> head active X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active natsFrom X -> natsFrom active X,
                        active s X -> s active X,
                 active sel(N, XS) -> mark head afterNth(N, XS),
                active sel(X1, X2) -> sel(X1, active X2),
                active sel(X1, X2) -> sel(active X1, X2),
                     active tail X -> tail active X,
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
               active take(X1, X2) -> take(X1, active X2),
               active take(X1, X2) -> take(active X1, X2),
          U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> mark pair(X1, X2),
                 pair(mark X1, X2) -> mark pair(X1, X2),
                pair(ok X1, ok X2) -> ok pair(X1, X2),
                 cons(mark X1, X2) -> mark cons(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                        snd mark X -> mark snd X,
                          snd ok X -> ok snd X,
             afterNth(X1, mark X2) -> mark afterNth(X1, X2),
             afterNth(mark X1, X2) -> mark afterNth(X1, X2),
            afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
                        fst mark X -> mark fst X,
                          fst ok X -> ok fst X,
                       head mark X -> mark head X,
                         head ok X -> ok head X,
                   natsFrom mark X -> mark natsFrom X,
                     natsFrom ok X -> ok natsFrom X,
                          s mark X -> mark s X,
                            s ok X -> ok s X,
                  sel(X1, mark X2) -> mark sel(X1, X2),
                  sel(mark X1, X2) -> mark sel(X1, X2),
                 sel(ok X1, ok X2) -> ok sel(X1, X2),
                       tail mark X -> mark tail X,
                         tail ok X -> ok tail X,
                 take(X1, mark X2) -> mark take(X1, X2),
                 take(mark X1, X2) -> mark take(X1, X2),
                take(ok X1, ok X2) -> ok take(X1, X2),
                proper U12(X1, X2) -> U12(proper X1, proper X2),
            proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
        proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                       proper tt() -> ok tt(),
               proper pair(X1, X2) -> pair(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper snd X -> snd proper X,
           proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                proper and(X1, X2) -> and(proper X1, proper X2),
                      proper fst X -> fst proper X,
                     proper head X -> head proper X,
                 proper natsFrom X -> natsFrom proper X,
                        proper s X -> s proper X,
                proper sel(X1, X2) -> sel(proper X1, proper X2),
                      proper nil() -> ok nil(),
                        proper 0() -> ok 0(),
                     proper tail X -> tail proper X,
               proper take(X1, X2) -> take(proper X1, proper X2),
                        top mark X -> top proper X,
                          top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [U11](x0, x1, x2, x3) = x0 + 1,
   
   [U12](x0, x1) = x0 + 1,
   
   [splitAt](x0, x1) = x0 + 1,
   
   [pair](x0, x1) = x0 + 1,
   
   [cons](x0, x1) = 1,
   
   [afterNth](x0, x1) = x0 + 1,
   
   [and](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [take](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [snd](x0) = x0 + 1,
   
   [fst](x0) = x0 + 1,
   
   [head](x0) = x0 + 1,
   
   [natsFrom](x0) = x0 + 1,
   
   [s](x0) = 1,
   
   [tail](x0) = x0 + 1,
   
   [proper](x0) = x0 + 1,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [tt] = 1,
   
   [nil] = 1,
   
   [0] = 1,
   
   [U12#](x0, x1) = x0
  Strict:
   U12#(ok X1, ok X2) -> U12#(X1, X2)
   1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
   U12#(mark X1, X2) -> U12#(X1, X2)
   0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper take(X1, X2) -> take(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper tail X -> tail proper X
   2 + 1X >= 2 + 1X
   proper 0() -> ok 0()
   2 >= 2
   proper nil() -> ok nil()
   2 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper s X -> s proper X
   2 + 0X >= 1 + 0X
   proper natsFrom X -> natsFrom proper X
   2 + 1X >= 2 + 1X
   proper head X -> head proper X
   2 + 1X >= 2 + 1X
   proper fst X -> fst proper X
   2 + 1X >= 2 + 1X
   proper and(X1, X2) -> and(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper snd X -> snd proper X
   2 + 1X >= 2 + 1X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper pair(X1, X2) -> pair(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   proper tt() -> ok tt()
   2 >= 2
   proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   proper U12(X1, X2) -> U12(proper X1, proper X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   take(ok X1, ok X2) -> ok take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(mark X1, X2) -> mark take(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   take(X1, mark X2) -> mark take(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   tail ok X -> ok tail X
   2 + 1X >= 2 + 1X
   tail mark X -> mark tail X
   2 + 1X >= 2 + 1X
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   s ok X -> ok s X
   1 + 0X >= 2 + 0X
   s mark X -> mark s X
   1 + 0X >= 2 + 0X
   natsFrom ok X -> ok natsFrom X
   2 + 1X >= 2 + 1X
   natsFrom mark X -> mark natsFrom X
   2 + 1X >= 2 + 1X
   head ok X -> ok head X
   2 + 1X >= 2 + 1X
   head mark X -> mark head X
   2 + 1X >= 2 + 1X
   fst ok X -> ok fst X
   2 + 1X >= 2 + 1X
   fst mark X -> mark fst X
   2 + 1X >= 2 + 1X
   and(ok X1, ok X2) -> ok and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   and(mark X1, X2) -> mark and(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(mark X1, X2) -> mark afterNth(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   afterNth(X1, mark X2) -> mark afterNth(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   snd ok X -> ok snd X
   2 + 1X >= 2 + 1X
   snd mark X -> mark snd X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   pair(ok X1, ok X2) -> ok pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(mark X1, X2) -> mark pair(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   pair(X1, mark X2) -> mark pair(X1, X2)
   1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active take(X1, X2) -> take(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active take(X1, X2) -> take(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active take(N, XS) -> mark fst splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active tail cons(N, XS) -> mark XS
   3 + 0N + 0XS >= 1 + 1XS
   active tail X -> tail active X
   2 + 1X >= 2 + 1X
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active sel(N, XS) -> mark head afterNth(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active s X -> s active X
   2 + 0X >= 1 + 0X
   active natsFrom X -> natsFrom active X
   2 + 1X >= 2 + 1X
   active natsFrom N -> mark cons(N, natsFrom s N)
   2 + 1N >= 2 + 0N
   active head cons(N, XS) -> mark N
   3 + 0N + 0XS >= 1 + 1N
   active head X -> head active X
   2 + 1X >= 2 + 1X
   active fst pair(X, Y) -> mark X
   3 + 1X + 0Y >= 1 + 1X
   active fst X -> fst active X
   2 + 1X >= 2 + 1X
   active and(tt(), X) -> mark X
   3 + 0X >= 1 + 1X
   active and(X1, X2) -> and(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active afterNth(X1, X2) -> afterNth(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active afterNth(X1, X2) -> afterNth(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active afterNth(N, XS) -> mark snd splitAt(N, XS)
   2 + 0N + 1XS >= 3 + 0N + 1XS
   active snd pair(X, Y) -> mark Y
   3 + 1X + 0Y >= 1 + 1Y
   active snd X -> snd active X
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active pair(X1, X2) -> pair(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   active pair(X1, X2) -> pair(X1, active X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
   3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
   active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
   2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
   active splitAt(0(), XS) -> mark pair(nil(), XS)
   2 + 1XS >= 3 + 0XS
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
   3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
   active splitAt(X1, X2) -> splitAt(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active splitAt(X1, X2) -> splitAt(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
   3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
   active U12(X1, X2) -> U12(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(mark X1, X2) -> mark splitAt(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   splitAt(X1, mark X2) -> mark splitAt(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   U12(ok X1, ok X2) -> ok U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   U12(mark X1, X2) -> mark U12(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {U12#(mark X1, X2) -> U12#(X1, X2)}
  
  SCC (1):
   Strict:
    {U12#(mark X1, X2) -> U12#(X1, X2)}
   Weak:
   {                U12(mark X1, X2) -> mark U12(X1, X2),
                   U12(ok X1, ok X2) -> ok U12(X1, X2),
                splitAt(X1, mark X2) -> mark splitAt(X1, X2),
                splitAt(mark X1, X2) -> mark splitAt(X1, X2),
               splitAt(ok X1, ok X2) -> ok splitAt(X1, X2),
                  active U12(X1, X2) -> U12(active X1, X2),
         active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
              active splitAt(X1, X2) -> splitAt(X1, active X2),
              active splitAt(X1, X2) -> splitAt(active X1, X2),
    active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
             active splitAt(0(), XS) -> mark pair(nil(), XS),
          active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4),
          active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                 active pair(X1, X2) -> pair(X1, active X2),
                 active pair(X1, X2) -> pair(active X1, X2),
                 active cons(X1, X2) -> cons(active X1, X2),
                        active snd X -> snd active X,
               active snd pair(X, Y) -> mark Y,
              active afterNth(N, XS) -> mark snd splitAt(N, XS),
             active afterNth(X1, X2) -> afterNth(X1, active X2),
             active afterNth(X1, X2) -> afterNth(active X1, X2),
                  active and(X1, X2) -> and(active X1, X2),
                 active and(tt(), X) -> mark X,
                        active fst X -> fst active X,
               active fst pair(X, Y) -> mark X,
                       active head X -> head active X,
             active head cons(N, XS) -> mark N,
                   active natsFrom N -> mark cons(N, natsFrom s N),
                   active natsFrom X -> natsFrom active X,
                          active s X -> s active X,
                   active sel(N, XS) -> mark head afterNth(N, XS),
                  active sel(X1, X2) -> sel(X1, active X2),
                  active sel(X1, X2) -> sel(active X1, X2),
                       active tail X -> tail active X,
             active tail cons(N, XS) -> mark XS,
                  active take(N, XS) -> mark fst splitAt(N, XS),
                 active take(X1, X2) -> take(X1, active X2),
                 active take(X1, X2) -> take(active X1, X2),
            U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4),
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4),
                   pair(X1, mark X2) -> mark pair(X1, X2),
                   pair(mark X1, X2) -> mark pair(X1, X2),
                  pair(ok X1, ok X2) -> ok pair(X1, X2),
                   cons(mark X1, X2) -> mark cons(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                          snd mark X -> mark snd X,
                            snd ok X -> ok snd X,
               afterNth(X1, mark X2) -> mark afterNth(X1, X2),
               afterNth(mark X1, X2) -> mark afterNth(X1, X2),
              afterNth(ok X1, ok X2) -> ok afterNth(X1, X2),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                          fst mark X -> mark fst X,
                            fst ok X -> ok fst X,
                         head mark X -> mark head X,
                           head ok X -> ok head X,
                     natsFrom mark X -> mark natsFrom X,
                       natsFrom ok X -> ok natsFrom X,
                            s mark X -> mark s X,
                              s ok X -> ok s X,
                    sel(X1, mark X2) -> mark sel(X1, X2),
                    sel(mark X1, X2) -> mark sel(X1, X2),
                   sel(ok X1, ok X2) -> ok sel(X1, X2),
                         tail mark X -> mark tail X,
                           tail ok X -> ok tail X,
                   take(X1, mark X2) -> mark take(X1, X2),
                   take(mark X1, X2) -> mark take(X1, X2),
                  take(ok X1, ok X2) -> ok take(X1, X2),
                  proper U12(X1, X2) -> U12(proper X1, proper X2),
              proper splitAt(X1, X2) -> splitAt(proper X1, proper X2),
          proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4),
                         proper tt() -> ok tt(),
                 proper pair(X1, X2) -> pair(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper snd X -> snd proper X,
             proper afterNth(X1, X2) -> afterNth(proper X1, proper X2),
                  proper and(X1, X2) -> and(proper X1, proper X2),
                        proper fst X -> fst proper X,
                       proper head X -> head proper X,
                   proper natsFrom X -> natsFrom proper X,
                          proper s X -> s proper X,
                  proper sel(X1, X2) -> sel(proper X1, proper X2),
                        proper nil() -> ok nil(),
                          proper 0() -> ok 0(),
                       proper tail X -> tail proper X,
                 proper take(X1, X2) -> take(proper X1, proper X2),
                          top mark X -> top proper X,
                            top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [U11](x0, x1, x2, x3) = x0 + 1,
     
     [U12](x0, x1) = x0 + 1,
     
     [splitAt](x0, x1) = x0 + 1,
     
     [pair](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = 1,
     
     [afterNth](x0, x1) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [take](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [snd](x0) = x0 + 1,
     
     [fst](x0) = x0 + 1,
     
     [head](x0) = x0 + 1,
     
     [natsFrom](x0) = x0 + 1,
     
     [s](x0) = 1,
     
     [tail](x0) = x0 + 1,
     
     [proper](x0) = x0 + 1,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [tt] = 1,
     
     [nil] = 1,
     
     [0] = 0,
     
     [U12#](x0, x1) = x0 + 1
    Strict:
     U12#(mark X1, X2) -> U12#(X1, X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 2 + 1X
     proper take(X1, X2) -> take(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper tail X -> tail proper X
     2 + 1X >= 2 + 1X
     proper 0() -> ok 0()
     1 >= 1
     proper nil() -> ok nil()
     2 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper s X -> s proper X
     2 + 0X >= 1 + 0X
     proper natsFrom X -> natsFrom proper X
     2 + 1X >= 2 + 1X
     proper head X -> head proper X
     2 + 1X >= 2 + 1X
     proper fst X -> fst proper X
     2 + 1X >= 2 + 1X
     proper and(X1, X2) -> and(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper afterNth(X1, X2) -> afterNth(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper snd X -> snd proper X
     2 + 1X >= 2 + 1X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper pair(X1, X2) -> pair(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     proper tt() -> ok tt()
     2 >= 2
     proper U11(X1, X2, X3, X4) -> U11(proper X1, proper X2, proper X3, proper X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     proper splitAt(X1, X2) -> splitAt(proper X1, proper X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     proper U12(X1, X2) -> U12(proper X1, proper X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     take(ok X1, ok X2) -> ok take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(mark X1, X2) -> mark take(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     take(X1, mark X2) -> mark take(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     tail ok X -> ok tail X
     2 + 1X >= 2 + 1X
     tail mark X -> mark tail X
     2 + 1X >= 2 + 1X
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 0X >= 2 + 0X
     s mark X -> mark s X
     1 + 0X >= 2 + 0X
     natsFrom ok X -> ok natsFrom X
     2 + 1X >= 2 + 1X
     natsFrom mark X -> mark natsFrom X
     2 + 1X >= 2 + 1X
     head ok X -> ok head X
     2 + 1X >= 2 + 1X
     head mark X -> mark head X
     2 + 1X >= 2 + 1X
     fst ok X -> ok fst X
     2 + 1X >= 2 + 1X
     fst mark X -> mark fst X
     2 + 1X >= 2 + 1X
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     afterNth(ok X1, ok X2) -> ok afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(mark X1, X2) -> mark afterNth(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     afterNth(X1, mark X2) -> mark afterNth(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     snd ok X -> ok snd X
     2 + 1X >= 2 + 1X
     snd mark X -> mark snd X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     pair(ok X1, ok X2) -> ok pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(mark X1, X2) -> mark pair(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     pair(X1, mark X2) -> mark pair(X1, X2)
     1 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U11(ok X1, ok X2, ok X3, ok X4) -> ok U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     U11(mark X1, X2, X3, X4) -> mark U11(X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active take(X1, X2) -> take(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active take(X1, X2) -> take(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active take(N, XS) -> mark fst splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active tail cons(N, XS) -> mark XS
     3 + 0N + 0XS >= 1 + 1XS
     active tail X -> tail active X
     2 + 1X >= 2 + 1X
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active sel(N, XS) -> mark head afterNth(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active s X -> s active X
     2 + 0X >= 1 + 0X
     active natsFrom X -> natsFrom active X
     2 + 1X >= 2 + 1X
     active natsFrom N -> mark cons(N, natsFrom s N)
     2 + 1N >= 2 + 0N
     active head cons(N, XS) -> mark N
     3 + 0N + 0XS >= 1 + 1N
     active head X -> head active X
     2 + 1X >= 2 + 1X
     active fst pair(X, Y) -> mark X
     3 + 1X + 0Y >= 1 + 1X
     active fst X -> fst active X
     2 + 1X >= 2 + 1X
     active and(tt(), X) -> mark X
     3 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active afterNth(X1, X2) -> afterNth(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active afterNth(X1, X2) -> afterNth(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active afterNth(N, XS) -> mark snd splitAt(N, XS)
     2 + 0N + 1XS >= 3 + 0N + 1XS
     active snd pair(X, Y) -> mark Y
     3 + 1X + 0Y >= 1 + 1Y
     active snd X -> snd active X
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active pair(X1, X2) -> pair(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active pair(X1, X2) -> pair(X1, active X2)
     2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X)
     3 + 0N + 0XS + 0X >= 3 + 0N + 1XS + 0X
     active U11(X1, X2, X3, X4) -> U11(active X1, X2, X3, X4)
     2 + 1X1 + 0X2 + 0X3 + 0X4 >= 2 + 1X1 + 0X2 + 0X3 + 0X4
     active splitAt(0(), XS) -> mark pair(nil(), XS)
     2 + 1XS >= 3 + 0XS
     active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS)
     3 + 0N + 0XS + 0X >= 3 + 0N + 0XS + 0X
     active splitAt(X1, X2) -> splitAt(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active splitAt(X1, X2) -> splitAt(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS)
     3 + 0X + 1YS + 0ZS >= 3 + 0X + 0YS + 0ZS
     active U12(X1, X2) -> U12(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     splitAt(ok X1, ok X2) -> ok splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(mark X1, X2) -> mark splitAt(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     splitAt(X1, mark X2) -> mark splitAt(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     U12(ok X1, ok X2) -> ok U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     U12(mark X1, X2) -> mark U12(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed