MAYBE
Time: 0.200885
TRS:
 {                mark U12(X1, X2) -> active U12(mark X1, X2),
              mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
          mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                         mark tt() -> active tt(),
                 mark pair(X1, X2) -> active pair(mark X1, mark X2),
                 mark cons(X1, X2) -> active cons(mark X1, X2),
                        mark snd X -> active snd mark X,
             mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                  mark and(X1, X2) -> active and(mark X1, X2),
                        mark fst X -> active fst mark X,
                       mark head X -> active head mark X,
                   mark natsFrom X -> active natsFrom mark X,
                          mark s X -> active s mark X,
                  mark sel(X1, X2) -> active sel(mark X1, mark X2),
                        mark nil() -> active nil(),
                          mark 0() -> active 0(),
                       mark tail X -> active tail mark X,
                 mark take(X1, X2) -> active take(mark X1, mark X2),
                  U12(X1, mark X2) -> U12(X1, X2),
                U12(X1, active X2) -> U12(X1, X2),
                  U12(mark X1, X2) -> U12(X1, X2),
                U12(active X1, X2) -> U12(X1, X2),
              splitAt(X1, mark X2) -> splitAt(X1, X2),
            splitAt(X1, active X2) -> splitAt(X1, X2),
              splitAt(mark X1, X2) -> splitAt(X1, X2),
            splitAt(active X1, X2) -> splitAt(X1, X2),
       active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
  active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
           active splitAt(0(), XS) -> mark pair(nil(), XS),
        active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
             active snd pair(X, Y) -> mark Y,
            active afterNth(N, XS) -> mark snd splitAt(N, XS),
               active and(tt(), X) -> mark X,
             active fst pair(X, Y) -> mark X,
           active head cons(N, XS) -> mark N,
                 active natsFrom N -> mark cons(N, natsFrom s N),
                 active sel(N, XS) -> mark head afterNth(N, XS),
           active tail cons(N, XS) -> mark XS,
                active take(N, XS) -> mark fst splitAt(N, XS),
          U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
        U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
          U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
        U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
          U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
        U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
          U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
        U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                 pair(X1, mark X2) -> pair(X1, X2),
               pair(X1, active X2) -> pair(X1, X2),
                 pair(mark X1, X2) -> pair(X1, X2),
               pair(active X1, X2) -> pair(X1, X2),
                 cons(X1, mark X2) -> cons(X1, X2),
               cons(X1, active X2) -> cons(X1, X2),
                 cons(mark X1, X2) -> cons(X1, X2),
               cons(active X1, X2) -> cons(X1, X2),
                        snd mark X -> snd X,
                      snd active X -> snd X,
             afterNth(X1, mark X2) -> afterNth(X1, X2),
           afterNth(X1, active X2) -> afterNth(X1, X2),
             afterNth(mark X1, X2) -> afterNth(X1, X2),
           afterNth(active X1, X2) -> afterNth(X1, X2),
                  and(X1, mark X2) -> and(X1, X2),
                and(X1, active X2) -> and(X1, X2),
                  and(mark X1, X2) -> and(X1, X2),
                and(active X1, X2) -> and(X1, X2),
                        fst mark X -> fst X,
                      fst active X -> fst X,
                       head mark X -> head X,
                     head active X -> head X,
                   natsFrom mark X -> natsFrom X,
                 natsFrom active X -> natsFrom X,
                          s mark X -> s X,
                        s active X -> s X,
                  sel(X1, mark X2) -> sel(X1, X2),
                sel(X1, active X2) -> sel(X1, X2),
                  sel(mark X1, X2) -> sel(X1, X2),
                sel(active X1, X2) -> sel(X1, X2),
                       tail mark X -> tail X,
                     tail active X -> tail X,
                 take(X1, mark X2) -> take(X1, X2),
               take(X1, active X2) -> take(X1, X2),
                 take(mark X1, X2) -> take(X1, X2),
               take(active X1, X2) -> take(X1, X2)}
 DP:
  DP:
   {                mark# U12(X1, X2) -> mark# X1,
                    mark# U12(X1, X2) -> U12#(mark X1, X2),
                    mark# U12(X1, X2) -> active# U12(mark X1, X2),
                mark# splitAt(X1, X2) -> mark# X1,
                mark# splitAt(X1, X2) -> mark# X2,
                mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2),
                mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2),
            mark# U11(X1, X2, X3, X4) -> mark# X1,
            mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4),
            mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4),
                           mark# tt() -> active# tt(),
                   mark# pair(X1, X2) -> mark# X1,
                   mark# pair(X1, X2) -> mark# X2,
                   mark# pair(X1, X2) -> active# pair(mark X1, mark X2),
                   mark# pair(X1, X2) -> pair#(mark X1, mark X2),
                   mark# cons(X1, X2) -> mark# X1,
                   mark# cons(X1, X2) -> active# cons(mark X1, X2),
                   mark# cons(X1, X2) -> cons#(mark X1, X2),
                          mark# snd X -> mark# X,
                          mark# snd X -> active# snd mark X,
                          mark# snd X -> snd# mark X,
               mark# afterNth(X1, X2) -> mark# X1,
               mark# afterNth(X1, X2) -> mark# X2,
               mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2),
               mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2),
                    mark# and(X1, X2) -> mark# X1,
                    mark# and(X1, X2) -> active# and(mark X1, X2),
                    mark# and(X1, X2) -> and#(mark X1, X2),
                          mark# fst X -> mark# X,
                          mark# fst X -> active# fst mark X,
                          mark# fst X -> fst# mark X,
                         mark# head X -> mark# X,
                         mark# head X -> active# head mark X,
                         mark# head X -> head# mark X,
                     mark# natsFrom X -> mark# X,
                     mark# natsFrom X -> active# natsFrom mark X,
                     mark# natsFrom X -> natsFrom# mark X,
                            mark# s X -> mark# X,
                            mark# s X -> active# s mark X,
                            mark# s X -> s# mark X,
                    mark# sel(X1, X2) -> mark# X1,
                    mark# sel(X1, X2) -> mark# X2,
                    mark# sel(X1, X2) -> active# sel(mark X1, mark X2),
                    mark# sel(X1, X2) -> sel#(mark X1, mark X2),
                          mark# nil() -> active# nil(),
                            mark# 0() -> active# 0(),
                         mark# tail X -> mark# X,
                         mark# tail X -> active# tail mark X,
                         mark# tail X -> tail# mark X,
                   mark# take(X1, X2) -> mark# X1,
                   mark# take(X1, X2) -> mark# X2,
                   mark# take(X1, X2) -> active# take(mark X1, mark X2),
                   mark# take(X1, X2) -> take#(mark X1, mark X2),
                    U12#(X1, mark X2) -> U12#(X1, X2),
                  U12#(X1, active X2) -> U12#(X1, X2),
                    U12#(mark X1, X2) -> U12#(X1, X2),
                  U12#(active X1, X2) -> U12#(X1, X2),
                splitAt#(X1, mark X2) -> splitAt#(X1, X2),
              splitAt#(X1, active X2) -> splitAt#(X1, X2),
                splitAt#(mark X1, X2) -> splitAt#(X1, X2),
              splitAt#(active X1, X2) -> splitAt#(X1, X2),
         active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS),
         active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS),
         active# U12(pair(YS, ZS), X) -> cons#(X, YS),
    active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS),
    active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS),
             active# splitAt(0(), XS) -> mark# pair(nil(), XS),
             active# splitAt(0(), XS) -> pair#(nil(), XS),
          active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X),
          active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X),
          active# U11(tt(), N, X, XS) -> splitAt#(N, XS),
               active# snd pair(X, Y) -> mark# Y,
              active# afterNth(N, XS) -> mark# snd splitAt(N, XS),
              active# afterNth(N, XS) -> splitAt#(N, XS),
              active# afterNth(N, XS) -> snd# splitAt(N, XS),
                 active# and(tt(), X) -> mark# X,
               active# fst pair(X, Y) -> mark# X,
             active# head cons(N, XS) -> mark# N,
                   active# natsFrom N -> mark# cons(N, natsFrom s N),
                   active# natsFrom N -> cons#(N, natsFrom s N),
                   active# natsFrom N -> natsFrom# s N,
                   active# natsFrom N -> s# N,
                   active# sel(N, XS) -> mark# head afterNth(N, XS),
                   active# sel(N, XS) -> afterNth#(N, XS),
                   active# sel(N, XS) -> head# afterNth(N, XS),
             active# tail cons(N, XS) -> mark# XS,
                  active# take(N, XS) -> mark# fst splitAt(N, XS),
                  active# take(N, XS) -> splitAt#(N, XS),
                  active# take(N, XS) -> fst# splitAt(N, XS),
            U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4),
          U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4),
            U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4),
          U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4),
            U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4),
          U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4),
            U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
          U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
                   pair#(X1, mark X2) -> pair#(X1, X2),
                 pair#(X1, active X2) -> pair#(X1, X2),
                   pair#(mark X1, X2) -> pair#(X1, X2),
                 pair#(active X1, X2) -> pair#(X1, X2),
                   cons#(X1, mark X2) -> cons#(X1, X2),
                 cons#(X1, active X2) -> cons#(X1, X2),
                   cons#(mark X1, X2) -> cons#(X1, X2),
                 cons#(active X1, X2) -> cons#(X1, X2),
                          snd# mark X -> snd# X,
                        snd# active X -> snd# X,
               afterNth#(X1, mark X2) -> afterNth#(X1, X2),
             afterNth#(X1, active X2) -> afterNth#(X1, X2),
               afterNth#(mark X1, X2) -> afterNth#(X1, X2),
             afterNth#(active X1, X2) -> afterNth#(X1, X2),
                    and#(X1, mark X2) -> and#(X1, X2),
                  and#(X1, active X2) -> and#(X1, X2),
                    and#(mark X1, X2) -> and#(X1, X2),
                  and#(active X1, X2) -> and#(X1, X2),
                          fst# mark X -> fst# X,
                        fst# active X -> fst# X,
                         head# mark X -> head# X,
                       head# active X -> head# X,
                     natsFrom# mark X -> natsFrom# X,
                   natsFrom# active X -> natsFrom# X,
                            s# mark X -> s# X,
                          s# active X -> s# X,
                    sel#(X1, mark X2) -> sel#(X1, X2),
                  sel#(X1, active X2) -> sel#(X1, X2),
                    sel#(mark X1, X2) -> sel#(X1, X2),
                  sel#(active X1, X2) -> sel#(X1, X2),
                         tail# mark X -> tail# X,
                       tail# active X -> tail# X,
                   take#(X1, mark X2) -> take#(X1, X2),
                 take#(X1, active X2) -> take#(X1, X2),
                   take#(mark X1, X2) -> take#(X1, X2),
                 take#(active X1, X2) -> take#(X1, X2)}
  TRS:
  {                mark U12(X1, X2) -> active U12(mark X1, X2),
               mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
           mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                          mark tt() -> active tt(),
                  mark pair(X1, X2) -> active pair(mark X1, mark X2),
                  mark cons(X1, X2) -> active cons(mark X1, X2),
                         mark snd X -> active snd mark X,
              mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                   mark and(X1, X2) -> active and(mark X1, X2),
                         mark fst X -> active fst mark X,
                        mark head X -> active head mark X,
                    mark natsFrom X -> active natsFrom mark X,
                           mark s X -> active s mark X,
                   mark sel(X1, X2) -> active sel(mark X1, mark X2),
                         mark nil() -> active nil(),
                           mark 0() -> active 0(),
                        mark tail X -> active tail mark X,
                  mark take(X1, X2) -> active take(mark X1, mark X2),
                   U12(X1, mark X2) -> U12(X1, X2),
                 U12(X1, active X2) -> U12(X1, X2),
                   U12(mark X1, X2) -> U12(X1, X2),
                 U12(active X1, X2) -> U12(X1, X2),
               splitAt(X1, mark X2) -> splitAt(X1, X2),
             splitAt(X1, active X2) -> splitAt(X1, X2),
               splitAt(mark X1, X2) -> splitAt(X1, X2),
             splitAt(active X1, X2) -> splitAt(X1, X2),
        active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
   active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
            active splitAt(0(), XS) -> mark pair(nil(), XS),
         active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
              active snd pair(X, Y) -> mark Y,
             active afterNth(N, XS) -> mark snd splitAt(N, XS),
                active and(tt(), X) -> mark X,
              active fst pair(X, Y) -> mark X,
            active head cons(N, XS) -> mark N,
                  active natsFrom N -> mark cons(N, natsFrom s N),
                  active sel(N, XS) -> mark head afterNth(N, XS),
            active tail cons(N, XS) -> mark XS,
                 active take(N, XS) -> mark fst splitAt(N, XS),
           U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
         U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
           U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
         U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
           U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
         U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
           U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
         U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                  pair(X1, mark X2) -> pair(X1, X2),
                pair(X1, active X2) -> pair(X1, X2),
                  pair(mark X1, X2) -> pair(X1, X2),
                pair(active X1, X2) -> pair(X1, X2),
                  cons(X1, mark X2) -> cons(X1, X2),
                cons(X1, active X2) -> cons(X1, X2),
                  cons(mark X1, X2) -> cons(X1, X2),
                cons(active X1, X2) -> cons(X1, X2),
                         snd mark X -> snd X,
                       snd active X -> snd X,
              afterNth(X1, mark X2) -> afterNth(X1, X2),
            afterNth(X1, active X2) -> afterNth(X1, X2),
              afterNth(mark X1, X2) -> afterNth(X1, X2),
            afterNth(active X1, X2) -> afterNth(X1, X2),
                   and(X1, mark X2) -> and(X1, X2),
                 and(X1, active X2) -> and(X1, X2),
                   and(mark X1, X2) -> and(X1, X2),
                 and(active X1, X2) -> and(X1, X2),
                         fst mark X -> fst X,
                       fst active X -> fst X,
                        head mark X -> head X,
                      head active X -> head X,
                    natsFrom mark X -> natsFrom X,
                  natsFrom active X -> natsFrom X,
                           s mark X -> s X,
                         s active X -> s X,
                   sel(X1, mark X2) -> sel(X1, X2),
                 sel(X1, active X2) -> sel(X1, X2),
                   sel(mark X1, X2) -> sel(X1, X2),
                 sel(active X1, X2) -> sel(X1, X2),
                        tail mark X -> tail X,
                      tail active X -> tail X,
                  take(X1, mark X2) -> take(X1, X2),
                take(X1, active X2) -> take(X1, X2),
                  take(mark X1, X2) -> take(X1, X2),
                take(active X1, X2) -> take(X1, X2)}
  EDG:
   {
    (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# splitAt(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# splitAt(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# splitAt(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# splitAt(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# pair(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# pair(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# pair(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# pair(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# pair(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# pair(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# pair(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# pair(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# pair(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# pair(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# afterNth(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# afterNth(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# afterNth(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# afterNth(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# sel(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# sel(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# sel(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# sel(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# sel(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# sel(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# sel(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# sel(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# sel(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# sel(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# sel(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> mark# X2)
    (active# tail cons(N, XS) -> mark# XS, mark# take(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# tail X -> tail# mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# tail X -> active# tail mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# tail X -> mark# X)
    (active# tail cons(N, XS) -> mark# XS, mark# 0() -> active# 0())
    (active# tail cons(N, XS) -> mark# XS, mark# nil() -> active# nil())
    (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> mark# X2)
    (active# tail cons(N, XS) -> mark# XS, mark# sel(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# s X -> s# mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# s X -> active# s mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# s X -> mark# X)
    (active# tail cons(N, XS) -> mark# XS, mark# natsFrom X -> natsFrom# mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# natsFrom X -> active# natsFrom mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# natsFrom X -> mark# X)
    (active# tail cons(N, XS) -> mark# XS, mark# head X -> head# mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# head X -> active# head mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# head X -> mark# X)
    (active# tail cons(N, XS) -> mark# XS, mark# fst X -> fst# mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# fst X -> active# fst mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# fst X -> mark# X)
    (active# tail cons(N, XS) -> mark# XS, mark# and(X1, X2) -> and#(mark X1, X2))
    (active# tail cons(N, XS) -> mark# XS, mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# tail cons(N, XS) -> mark# XS, mark# and(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> mark# X2)
    (active# tail cons(N, XS) -> mark# XS, mark# afterNth(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# snd X -> snd# mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# snd X -> active# snd mark X)
    (active# tail cons(N, XS) -> mark# XS, mark# snd X -> mark# X)
    (active# tail cons(N, XS) -> mark# XS, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# tail cons(N, XS) -> mark# XS, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# tail cons(N, XS) -> mark# XS, mark# cons(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> mark# X2)
    (active# tail cons(N, XS) -> mark# XS, mark# pair(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# tt() -> active# tt())
    (active# tail cons(N, XS) -> mark# XS, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# tail cons(N, XS) -> mark# XS, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# tail cons(N, XS) -> mark# XS, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> mark# X2)
    (active# tail cons(N, XS) -> mark# XS, mark# splitAt(X1, X2) -> mark# X1)
    (active# tail cons(N, XS) -> mark# XS, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# tail cons(N, XS) -> mark# XS, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# tail cons(N, XS) -> mark# XS, mark# U12(X1, X2) -> mark# X1)
    (mark# nil() -> active# nil(), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# nil() -> active# nil(), active# take(N, XS) -> splitAt#(N, XS))
    (mark# nil() -> active# nil(), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# nil() -> active# nil(), active# tail cons(N, XS) -> mark# XS)
    (mark# nil() -> active# nil(), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# nil() -> active# nil(), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# nil() -> active# nil(), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# nil() -> active# nil(), active# natsFrom N -> s# N)
    (mark# nil() -> active# nil(), active# natsFrom N -> natsFrom# s N)
    (mark# nil() -> active# nil(), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# nil() -> active# nil(), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# nil() -> active# nil(), active# head cons(N, XS) -> mark# N)
    (mark# nil() -> active# nil(), active# fst pair(X, Y) -> mark# X)
    (mark# nil() -> active# nil(), active# and(tt(), X) -> mark# X)
    (mark# nil() -> active# nil(), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# nil() -> active# nil(), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# nil() -> active# nil(), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# nil() -> active# nil(), active# snd pair(X, Y) -> mark# Y)
    (mark# nil() -> active# nil(), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# nil() -> active# nil(), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# nil() -> active# nil(), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# nil() -> active# nil(), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# nil() -> active# nil(), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# nil() -> active# nil(), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# nil() -> active# nil(), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# nil() -> active# nil(), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# nil() -> active# nil(), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# nil() -> active# nil(), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# U12(X1, X2) -> U12#(mark X1, X2), U12#(active X1, X2) -> U12#(X1, X2))
    (mark# U12(X1, X2) -> U12#(mark X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
    (mark# U12(X1, X2) -> U12#(mark X1, X2), U12#(X1, active X2) -> U12#(X1, X2))
    (mark# U12(X1, X2) -> U12#(mark X1, X2), U12#(X1, mark X2) -> U12#(X1, X2))
    (mark# and(X1, X2) -> and#(mark X1, X2), and#(active X1, X2) -> and#(X1, X2))
    (mark# and(X1, X2) -> and#(mark X1, X2), and#(mark X1, X2) -> and#(X1, X2))
    (mark# and(X1, X2) -> and#(mark X1, X2), and#(X1, active X2) -> and#(X1, X2))
    (mark# and(X1, X2) -> and#(mark X1, X2), and#(X1, mark X2) -> and#(X1, X2))
    (U12#(X1, active X2) -> U12#(X1, X2), U12#(active X1, X2) -> U12#(X1, X2))
    (U12#(X1, active X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
    (U12#(X1, active X2) -> U12#(X1, X2), U12#(X1, active X2) -> U12#(X1, X2))
    (U12#(X1, active X2) -> U12#(X1, X2), U12#(X1, mark X2) -> U12#(X1, X2))
    (U12#(active X1, X2) -> U12#(X1, X2), U12#(active X1, X2) -> U12#(X1, X2))
    (U12#(active X1, X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
    (U12#(active X1, X2) -> U12#(X1, X2), U12#(X1, active X2) -> U12#(X1, X2))
    (U12#(active X1, X2) -> U12#(X1, X2), U12#(X1, mark X2) -> U12#(X1, X2))
    (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2))
    (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
    (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2))
    (splitAt#(X1, active X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
    (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2))
    (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
    (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2))
    (splitAt#(active X1, X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
    (pair#(X1, mark X2) -> pair#(X1, X2), pair#(active X1, 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#(X1, active 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#(active X1, 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, active X2) -> pair#(X1, X2))
    (pair#(mark X1, X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
    (cons#(X1, mark X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (cons#(X1, mark X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (cons#(X1, mark X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (cons#(mark X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (cons#(mark X1, X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (cons#(mark X1, X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(active X1, 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, active X2) -> afterNth#(X1, X2))
    (afterNth#(X1, mark X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
    (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, 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#(X1, active X2) -> afterNth#(X1, X2))
    (afterNth#(mark X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
    (and#(X1, mark X2) -> and#(X1, X2), and#(active X1, X2) -> and#(X1, X2))
    (and#(X1, mark X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
    (and#(X1, mark X2) -> and#(X1, X2), and#(X1, active X2) -> and#(X1, X2))
    (and#(X1, mark X2) -> and#(X1, X2), and#(X1, mark X2) -> and#(X1, X2))
    (and#(mark X1, X2) -> and#(X1, X2), and#(active X1, X2) -> and#(X1, X2))
    (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
    (and#(mark X1, X2) -> and#(X1, X2), and#(X1, active X2) -> and#(X1, X2))
    (and#(mark X1, X2) -> and#(X1, X2), and#(X1, mark X2) -> and#(X1, X2))
    (sel#(X1, mark X2) -> sel#(X1, X2), sel#(active X1, 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#(X1, active 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#(active X1, 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, active 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#(active X1, 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, active X2) -> take#(X1, X2))
    (take#(X1, mark X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
    (take#(mark X1, X2) -> take#(X1, X2), take#(active X1, 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#(X1, active X2) -> take#(X1, X2))
    (take#(mark X1, X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> s# N)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> natsFrom# s N)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# head cons(N, XS) -> mark# N)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# fst pair(X, Y) -> mark# X)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# and(tt(), X) -> mark# X)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# snd pair(X, Y) -> mark# Y)
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> s# N)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> natsFrom# s N)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# head cons(N, XS) -> mark# N)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# fst pair(X, Y) -> mark# X)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# and(tt(), X) -> mark# X)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# snd pair(X, Y) -> mark# Y)
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> s# N)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> natsFrom# s N)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# head cons(N, XS) -> mark# N)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# fst pair(X, Y) -> mark# X)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# and(tt(), X) -> mark# X)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# snd pair(X, Y) -> mark# Y)
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# take(X1, X2) -> active# take(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (active# snd pair(X, Y) -> mark# Y, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# take(X1, X2) -> mark# X2)
    (active# snd pair(X, Y) -> mark# Y, mark# take(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# tail X -> tail# mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# tail X -> active# tail mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# tail X -> mark# X)
    (active# snd pair(X, Y) -> mark# Y, mark# 0() -> active# 0())
    (active# snd pair(X, Y) -> mark# Y, mark# nil() -> active# nil())
    (active# snd pair(X, Y) -> mark# Y, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# sel(X1, X2) -> mark# X2)
    (active# snd pair(X, Y) -> mark# Y, mark# sel(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# s X -> s# mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# s X -> active# s mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# s X -> mark# X)
    (active# snd pair(X, Y) -> mark# Y, mark# natsFrom X -> natsFrom# mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# natsFrom X -> active# natsFrom mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# natsFrom X -> mark# X)
    (active# snd pair(X, Y) -> mark# Y, mark# head X -> head# mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# head X -> active# head mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# head X -> mark# X)
    (active# snd pair(X, Y) -> mark# Y, mark# fst X -> fst# mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# fst X -> active# fst mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# fst X -> mark# X)
    (active# snd pair(X, Y) -> mark# Y, mark# and(X1, X2) -> and#(mark X1, X2))
    (active# snd pair(X, Y) -> mark# Y, mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# snd pair(X, Y) -> mark# Y, mark# and(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# afterNth(X1, X2) -> mark# X2)
    (active# snd pair(X, Y) -> mark# Y, mark# afterNth(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# snd X -> snd# mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# snd X -> active# snd mark X)
    (active# snd pair(X, Y) -> mark# Y, mark# snd X -> mark# X)
    (active# snd pair(X, Y) -> mark# Y, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# snd pair(X, Y) -> mark# Y, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# snd pair(X, Y) -> mark# Y, mark# cons(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# pair(X1, X2) -> mark# X2)
    (active# snd pair(X, Y) -> mark# Y, mark# pair(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# tt() -> active# tt())
    (active# snd pair(X, Y) -> mark# Y, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# snd pair(X, Y) -> mark# Y, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# snd pair(X, Y) -> mark# Y, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# snd pair(X, Y) -> mark# Y, mark# splitAt(X1, X2) -> mark# X2)
    (active# snd pair(X, Y) -> mark# Y, mark# splitAt(X1, X2) -> mark# X1)
    (active# snd pair(X, Y) -> mark# Y, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# snd pair(X, Y) -> mark# Y, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# snd pair(X, Y) -> mark# Y, mark# U12(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(active X1, X2) -> pair#(X1, X2))
    (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(mark X1, X2) -> pair#(X1, X2))
    (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(X1, active X2) -> pair#(X1, X2))
    (mark# pair(X1, X2) -> pair#(mark X1, mark X2), pair#(X1, mark X2) -> pair#(X1, X2))
    (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(active X1, X2) -> sel#(X1, X2))
    (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(mark X1, X2) -> sel#(X1, X2))
    (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(X1, active X2) -> sel#(X1, X2))
    (mark# sel(X1, X2) -> sel#(mark X1, mark X2), sel#(X1, mark X2) -> sel#(X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> mark# X2)
    (active# head cons(N, XS) -> mark# N, mark# take(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# tail X -> tail# mark X)
    (active# head cons(N, XS) -> mark# N, mark# tail X -> active# tail mark X)
    (active# head cons(N, XS) -> mark# N, mark# tail X -> mark# X)
    (active# head cons(N, XS) -> mark# N, mark# 0() -> active# 0())
    (active# head cons(N, XS) -> mark# N, mark# nil() -> active# nil())
    (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> mark# X2)
    (active# head cons(N, XS) -> mark# N, mark# sel(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# s X -> s# mark X)
    (active# head cons(N, XS) -> mark# N, mark# s X -> active# s mark X)
    (active# head cons(N, XS) -> mark# N, mark# s X -> mark# X)
    (active# head cons(N, XS) -> mark# N, mark# natsFrom X -> natsFrom# mark X)
    (active# head cons(N, XS) -> mark# N, mark# natsFrom X -> active# natsFrom mark X)
    (active# head cons(N, XS) -> mark# N, mark# natsFrom X -> mark# X)
    (active# head cons(N, XS) -> mark# N, mark# head X -> head# mark X)
    (active# head cons(N, XS) -> mark# N, mark# head X -> active# head mark X)
    (active# head cons(N, XS) -> mark# N, mark# head X -> mark# X)
    (active# head cons(N, XS) -> mark# N, mark# fst X -> fst# mark X)
    (active# head cons(N, XS) -> mark# N, mark# fst X -> active# fst mark X)
    (active# head cons(N, XS) -> mark# N, mark# fst X -> mark# X)
    (active# head cons(N, XS) -> mark# N, mark# and(X1, X2) -> and#(mark X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# and(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> mark# X2)
    (active# head cons(N, XS) -> mark# N, mark# afterNth(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# snd X -> snd# mark X)
    (active# head cons(N, XS) -> mark# N, mark# snd X -> active# snd mark X)
    (active# head cons(N, XS) -> mark# N, mark# snd X -> mark# X)
    (active# head cons(N, XS) -> mark# N, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# cons(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> mark# X2)
    (active# head cons(N, XS) -> mark# N, mark# pair(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# tt() -> active# tt())
    (active# head cons(N, XS) -> mark# N, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# head cons(N, XS) -> mark# N, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# head cons(N, XS) -> mark# N, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> mark# X2)
    (active# head cons(N, XS) -> mark# N, mark# splitAt(X1, X2) -> mark# X1)
    (active# head cons(N, XS) -> mark# N, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# head cons(N, XS) -> mark# N, mark# U12(X1, X2) -> mark# X1)
    (mark# snd X -> snd# mark X, snd# active X -> snd# X)
    (mark# snd X -> snd# mark X, snd# mark X -> snd# X)
    (mark# head X -> head# mark X, head# active X -> head# X)
    (mark# head X -> head# mark X, head# mark X -> head# X)
    (mark# s X -> s# mark X, s# active X -> s# X)
    (mark# s X -> s# mark X, s# mark X -> s# X)
    (active# natsFrom N -> natsFrom# s N, natsFrom# active X -> natsFrom# X)
    (active# natsFrom N -> natsFrom# s N, natsFrom# mark X -> natsFrom# X)
    (active# afterNth(N, XS) -> splitAt#(N, XS), splitAt#(active X1, 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, active 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#(active X1, 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, active X2) -> splitAt#(X1, X2))
    (active# take(N, XS) -> splitAt#(N, XS), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# take(X1, X2) -> mark# X2)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# take(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# tail X -> tail# mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# tail X -> active# tail mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# tail X -> mark# X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# 0() -> active# 0())
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# nil() -> active# nil())
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# sel(X1, X2) -> mark# X2)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# sel(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# s X -> s# mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# s X -> active# s mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# s X -> mark# X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# natsFrom X -> natsFrom# mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# natsFrom X -> active# natsFrom mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# natsFrom X -> mark# X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# head X -> head# mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# head X -> active# head mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# head X -> mark# X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# fst X -> fst# mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# fst X -> active# fst mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# fst X -> mark# X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# and(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# afterNth(X1, X2) -> mark# X2)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# afterNth(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# snd X -> snd# mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# snd X -> active# snd mark X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# snd X -> mark# X)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# cons(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# pair(X1, X2) -> mark# X2)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# pair(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# tt() -> active# tt())
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# splitAt(X1, X2) -> mark# X2)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# splitAt(X1, X2) -> mark# X1)
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS), mark# U12(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(active X1, X2) -> cons#(X1, X2))
    (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(mark X1, X2) -> cons#(X1, X2))
    (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(X1, active X2) -> cons#(X1, X2))
    (active# U12(pair(YS, ZS), X) -> cons#(X, YS), cons#(X1, mark X2) -> cons#(X1, X2))
    (mark# fst X -> active# fst mark X, active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# fst X -> active# fst mark X, active# take(N, XS) -> splitAt#(N, XS))
    (mark# fst X -> active# fst mark X, active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# fst X -> active# fst mark X, active# tail cons(N, XS) -> mark# XS)
    (mark# fst X -> active# fst mark X, active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# fst X -> active# fst mark X, active# sel(N, XS) -> afterNth#(N, XS))
    (mark# fst X -> active# fst mark X, active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# fst X -> active# fst mark X, active# natsFrom N -> s# N)
    (mark# fst X -> active# fst mark X, active# natsFrom N -> natsFrom# s N)
    (mark# fst X -> active# fst mark X, active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# fst X -> active# fst mark X, active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# fst X -> active# fst mark X, active# head cons(N, XS) -> mark# N)
    (mark# fst X -> active# fst mark X, active# fst pair(X, Y) -> mark# X)
    (mark# fst X -> active# fst mark X, active# and(tt(), X) -> mark# X)
    (mark# fst X -> active# fst mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# fst X -> active# fst mark X, active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# fst X -> active# fst mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# fst X -> active# fst mark X, active# snd pair(X, Y) -> mark# Y)
    (mark# fst X -> active# fst mark X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# fst X -> active# fst mark X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# fst X -> active# fst mark X, active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# fst X -> active# fst mark X, active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# fst X -> active# fst mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# fst X -> active# fst mark X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# fst X -> active# fst mark X, active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# fst X -> active# fst mark X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# fst X -> active# fst mark X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# fst X -> active# fst mark X, active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# natsFrom X -> active# natsFrom mark X, active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# take(N, XS) -> splitAt#(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# tail cons(N, XS) -> mark# XS)
    (mark# natsFrom X -> active# natsFrom mark X, active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# sel(N, XS) -> afterNth#(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> s# N)
    (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> natsFrom# s N)
    (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# natsFrom X -> active# natsFrom mark X, active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# natsFrom X -> active# natsFrom mark X, active# head cons(N, XS) -> mark# N)
    (mark# natsFrom X -> active# natsFrom mark X, active# fst pair(X, Y) -> mark# X)
    (mark# natsFrom X -> active# natsFrom mark X, active# and(tt(), X) -> mark# X)
    (mark# natsFrom X -> active# natsFrom mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# snd pair(X, Y) -> mark# Y)
    (mark# natsFrom X -> active# natsFrom mark X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# natsFrom X -> active# natsFrom mark X, active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# natsFrom X -> active# natsFrom mark X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# natsFrom X -> active# natsFrom mark X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# natsFrom X -> active# natsFrom mark X, active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# tail X -> active# tail mark X, active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# tail X -> active# tail mark X, active# take(N, XS) -> splitAt#(N, XS))
    (mark# tail X -> active# tail mark X, active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# tail X -> active# tail mark X, active# tail cons(N, XS) -> mark# XS)
    (mark# tail X -> active# tail mark X, active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# tail X -> active# tail mark X, active# sel(N, XS) -> afterNth#(N, XS))
    (mark# tail X -> active# tail mark X, active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# tail X -> active# tail mark X, active# natsFrom N -> s# N)
    (mark# tail X -> active# tail mark X, active# natsFrom N -> natsFrom# s N)
    (mark# tail X -> active# tail mark X, active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# tail X -> active# tail mark X, active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# tail X -> active# tail mark X, active# head cons(N, XS) -> mark# N)
    (mark# tail X -> active# tail mark X, active# fst pair(X, Y) -> mark# X)
    (mark# tail X -> active# tail mark X, active# and(tt(), X) -> mark# X)
    (mark# tail X -> active# tail mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# tail X -> active# tail mark X, active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# tail X -> active# tail mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# tail X -> active# tail mark X, active# snd pair(X, Y) -> mark# Y)
    (mark# tail X -> active# tail mark X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# tail X -> active# tail mark X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# tail X -> active# tail mark X, active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# tail X -> active# tail mark X, active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# tail X -> active# tail mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# tail X -> active# tail mark X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# tail X -> active# tail mark X, active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# tail X -> active# tail mark X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# tail X -> active# tail mark X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# tail X -> active# tail mark X, active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (active# natsFrom N -> cons#(N, natsFrom s N), cons#(active X1, X2) -> cons#(X1, X2))
    (active# natsFrom N -> cons#(N, natsFrom s N), cons#(mark X1, X2) -> cons#(X1, X2))
    (active# natsFrom N -> cons#(N, natsFrom s N), cons#(X1, active X2) -> cons#(X1, X2))
    (active# natsFrom N -> cons#(N, natsFrom s N), cons#(X1, mark X2) -> cons#(X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> mark# X2)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# take(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tail X -> tail# mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tail X -> active# tail mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tail X -> mark# X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# 0() -> active# 0())
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# nil() -> active# nil())
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> mark# X2)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# sel(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# s X -> s# mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# s X -> active# s mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# s X -> mark# X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# natsFrom X -> natsFrom# mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# natsFrom X -> active# natsFrom mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# natsFrom X -> mark# X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# head X -> head# mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# head X -> active# head mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# head X -> mark# X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# fst X -> fst# mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# fst X -> active# fst mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# fst X -> mark# X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# and(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X2)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# snd X -> snd# mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# snd X -> active# snd mark X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# snd X -> mark# X)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# cons(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> mark# X2)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# pair(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# tt() -> active# tt())
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X2)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X1)
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# take(N, XS) -> mark# fst splitAt(N, XS), mark# U12(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# tail X -> tail# mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# tail X -> mark# X)
    (mark# pair(X1, X2) -> mark# X2, mark# 0() -> active# 0())
    (mark# pair(X1, X2) -> mark# X2, mark# nil() -> active# nil())
    (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# s X -> s# mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# s X -> active# s mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# s X -> mark# X)
    (mark# pair(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X)
    (mark# pair(X1, X2) -> mark# X2, mark# head X -> head# mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# head X -> active# head mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# head X -> mark# X)
    (mark# pair(X1, X2) -> mark# X2, mark# fst X -> fst# mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# fst X -> mark# X)
    (mark# pair(X1, X2) -> mark# X2, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X2, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X2, mark# and(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# snd X -> snd# mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X)
    (mark# pair(X1, X2) -> mark# X2, mark# snd X -> mark# X)
    (mark# pair(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# tt() -> active# tt())
    (mark# pair(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# pair(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# pair(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2)
    (mark# pair(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1)
    (mark# pair(X1, X2) -> mark# X2, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X2, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# pair(X1, X2) -> mark# X2, mark# U12(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# tail X -> tail# mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# tail X -> mark# X)
    (mark# sel(X1, X2) -> mark# X2, mark# 0() -> active# 0())
    (mark# sel(X1, X2) -> mark# X2, mark# nil() -> active# nil())
    (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# s X -> s# mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# s X -> active# s mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# s X -> mark# X)
    (mark# sel(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X)
    (mark# sel(X1, X2) -> mark# X2, mark# head X -> head# mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# head X -> active# head mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# head X -> mark# X)
    (mark# sel(X1, X2) -> mark# X2, mark# fst X -> fst# mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# fst X -> mark# X)
    (mark# sel(X1, X2) -> mark# X2, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X2, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X2, mark# and(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# snd X -> snd# mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X)
    (mark# sel(X1, X2) -> mark# X2, mark# snd X -> mark# X)
    (mark# sel(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# tt() -> active# tt())
    (mark# sel(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# sel(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# sel(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2)
    (mark# sel(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1)
    (mark# sel(X1, X2) -> mark# X2, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X2, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# sel(X1, X2) -> mark# X2, mark# U12(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# tail cons(N, XS) -> mark# XS)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# natsFrom N -> s# N)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# natsFrom N -> natsFrom# s N)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# head cons(N, XS) -> mark# N)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# fst pair(X, Y) -> mark# X)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# and(tt(), X) -> mark# X)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# snd pair(X, Y) -> mark# Y)
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# U12(X1, X2) -> active# U12(mark X1, X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# tail cons(N, XS) -> mark# XS)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# natsFrom N -> s# N)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# natsFrom N -> natsFrom# s N)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# head cons(N, XS) -> mark# N)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# fst pair(X, Y) -> mark# X)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# and(tt(), X) -> mark# X)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# snd pair(X, Y) -> mark# Y)
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# and(X1, X2) -> active# and(mark X1, X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> mark# X2)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# take(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tail X -> tail# mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tail X -> active# tail mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tail X -> mark# X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# 0() -> active# 0())
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# nil() -> active# nil())
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> mark# X2)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# sel(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# s X -> s# mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# s X -> active# s mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# s X -> mark# X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# natsFrom X -> natsFrom# mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# natsFrom X -> active# natsFrom mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# natsFrom X -> mark# X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# head X -> head# mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# head X -> active# head mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# head X -> mark# X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# fst X -> fst# mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# fst X -> active# fst mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# fst X -> mark# X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# and(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> mark# X2)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# afterNth(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# snd X -> snd# mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# snd X -> active# snd mark X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# snd X -> mark# X)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# cons(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> mark# X2)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# pair(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# tt() -> active# tt())
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> mark# X2)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# splitAt(X1, X2) -> mark# X1)
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# splitAt(0(), XS) -> mark# pair(nil(), XS), mark# U12(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# active X -> snd# X)
    (active# afterNth(N, XS) -> snd# splitAt(N, XS), snd# mark X -> snd# X)
    (active# take(N, XS) -> fst# splitAt(N, XS), fst# active X -> fst# X)
    (active# take(N, XS) -> fst# splitAt(N, XS), fst# mark X -> fst# X)
    (mark# fst X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# take(X1, X2) -> mark# X2)
    (mark# fst X -> mark# X, mark# take(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# tail X -> tail# mark X)
    (mark# fst X -> mark# X, mark# tail X -> active# tail mark X)
    (mark# fst X -> mark# X, mark# tail X -> mark# X)
    (mark# fst X -> mark# X, mark# 0() -> active# 0())
    (mark# fst X -> mark# X, mark# nil() -> active# nil())
    (mark# fst X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (mark# fst X -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# s X -> s# mark X)
    (mark# fst X -> mark# X, mark# s X -> active# s mark X)
    (mark# fst X -> mark# X, mark# s X -> mark# X)
    (mark# fst X -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (mark# fst X -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (mark# fst X -> mark# X, mark# natsFrom X -> mark# X)
    (mark# fst X -> mark# X, mark# head X -> head# mark X)
    (mark# fst X -> mark# X, mark# head X -> active# head mark X)
    (mark# fst X -> mark# X, mark# head X -> mark# X)
    (mark# fst X -> mark# X, mark# fst X -> fst# mark X)
    (mark# fst X -> mark# X, mark# fst X -> active# fst mark X)
    (mark# fst X -> mark# X, mark# fst X -> mark# X)
    (mark# fst X -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# fst X -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# fst X -> mark# X, mark# and(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (mark# fst X -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# snd X -> snd# mark X)
    (mark# fst X -> mark# X, mark# snd X -> active# snd mark X)
    (mark# fst X -> mark# X, mark# snd X -> mark# X)
    (mark# fst X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# fst X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# fst X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (mark# fst X -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# tt() -> active# tt())
    (mark# fst X -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# fst X -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# fst X -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (mark# fst X -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (mark# fst X -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# fst X -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# fst X -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> mark# X2)
    (mark# natsFrom X -> mark# X, mark# take(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# tail X -> tail# mark X)
    (mark# natsFrom X -> mark# X, mark# tail X -> active# tail mark X)
    (mark# natsFrom X -> mark# X, mark# tail X -> mark# X)
    (mark# natsFrom X -> mark# X, mark# 0() -> active# 0())
    (mark# natsFrom X -> mark# X, mark# nil() -> active# nil())
    (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (mark# natsFrom X -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# s X -> s# mark X)
    (mark# natsFrom X -> mark# X, mark# s X -> active# s mark X)
    (mark# natsFrom X -> mark# X, mark# s X -> mark# X)
    (mark# natsFrom X -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (mark# natsFrom X -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (mark# natsFrom X -> mark# X, mark# natsFrom X -> mark# X)
    (mark# natsFrom X -> mark# X, mark# head X -> head# mark X)
    (mark# natsFrom X -> mark# X, mark# head X -> active# head mark X)
    (mark# natsFrom X -> mark# X, mark# head X -> mark# X)
    (mark# natsFrom X -> mark# X, mark# fst X -> fst# mark X)
    (mark# natsFrom X -> mark# X, mark# fst X -> active# fst mark X)
    (mark# natsFrom X -> mark# X, mark# fst X -> mark# X)
    (mark# natsFrom X -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# natsFrom X -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# natsFrom X -> mark# X, mark# and(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (mark# natsFrom X -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# snd X -> snd# mark X)
    (mark# natsFrom X -> mark# X, mark# snd X -> active# snd mark X)
    (mark# natsFrom X -> mark# X, mark# snd X -> mark# X)
    (mark# natsFrom X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# natsFrom X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# natsFrom X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (mark# natsFrom X -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# tt() -> active# tt())
    (mark# natsFrom X -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# natsFrom X -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# natsFrom X -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (mark# natsFrom X -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (mark# natsFrom X -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# natsFrom X -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# natsFrom X -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# take(X1, X2) -> mark# X2)
    (mark# tail X -> mark# X, mark# take(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# tail X -> tail# mark X)
    (mark# tail X -> mark# X, mark# tail X -> active# tail mark X)
    (mark# tail X -> mark# X, mark# tail X -> mark# X)
    (mark# tail X -> mark# X, mark# 0() -> active# 0())
    (mark# tail X -> mark# X, mark# nil() -> active# nil())
    (mark# tail X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (mark# tail X -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# s X -> s# mark X)
    (mark# tail X -> mark# X, mark# s X -> active# s mark X)
    (mark# tail X -> mark# X, mark# s X -> mark# X)
    (mark# tail X -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (mark# tail X -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (mark# tail X -> mark# X, mark# natsFrom X -> mark# X)
    (mark# tail X -> mark# X, mark# head X -> head# mark X)
    (mark# tail X -> mark# X, mark# head X -> active# head mark X)
    (mark# tail X -> mark# X, mark# head X -> mark# X)
    (mark# tail X -> mark# X, mark# fst X -> fst# mark X)
    (mark# tail X -> mark# X, mark# fst X -> active# fst mark X)
    (mark# tail X -> mark# X, mark# fst X -> mark# X)
    (mark# tail X -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# tail X -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# tail X -> mark# X, mark# and(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (mark# tail X -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# snd X -> snd# mark X)
    (mark# tail X -> mark# X, mark# snd X -> active# snd mark X)
    (mark# tail X -> mark# X, mark# snd X -> mark# X)
    (mark# tail X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# tail X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# tail X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (mark# tail X -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# tt() -> active# tt())
    (mark# tail X -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# tail X -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# tail X -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (mark# tail X -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (mark# tail X -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# tail X -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# tail X -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# take(X1, X2) -> mark# X2)
    (active# fst pair(X, Y) -> mark# X, mark# take(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# tail X -> tail# mark X)
    (active# fst pair(X, Y) -> mark# X, mark# tail X -> active# tail mark X)
    (active# fst pair(X, Y) -> mark# X, mark# tail X -> mark# X)
    (active# fst pair(X, Y) -> mark# X, mark# 0() -> active# 0())
    (active# fst pair(X, Y) -> mark# X, mark# nil() -> active# nil())
    (active# fst pair(X, Y) -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (active# fst pair(X, Y) -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# s X -> s# mark X)
    (active# fst pair(X, Y) -> mark# X, mark# s X -> active# s mark X)
    (active# fst pair(X, Y) -> mark# X, mark# s X -> mark# X)
    (active# fst pair(X, Y) -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (active# fst pair(X, Y) -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (active# fst pair(X, Y) -> mark# X, mark# natsFrom X -> mark# X)
    (active# fst pair(X, Y) -> mark# X, mark# head X -> head# mark X)
    (active# fst pair(X, Y) -> mark# X, mark# head X -> active# head mark X)
    (active# fst pair(X, Y) -> mark# X, mark# head X -> mark# X)
    (active# fst pair(X, Y) -> mark# X, mark# fst X -> fst# mark X)
    (active# fst pair(X, Y) -> mark# X, mark# fst X -> active# fst mark X)
    (active# fst pair(X, Y) -> mark# X, mark# fst X -> mark# X)
    (active# fst pair(X, Y) -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (active# fst pair(X, Y) -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# fst pair(X, Y) -> mark# X, mark# and(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (active# fst pair(X, Y) -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# snd X -> snd# mark X)
    (active# fst pair(X, Y) -> mark# X, mark# snd X -> active# snd mark X)
    (active# fst pair(X, Y) -> mark# X, mark# snd X -> mark# X)
    (active# fst pair(X, Y) -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# fst pair(X, Y) -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# fst pair(X, Y) -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (active# fst pair(X, Y) -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# tt() -> active# tt())
    (active# fst pair(X, Y) -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# fst pair(X, Y) -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# fst pair(X, Y) -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# fst pair(X, Y) -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (active# fst pair(X, Y) -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (active# fst pair(X, Y) -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# fst pair(X, Y) -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# fst pair(X, Y) -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (snd# active X -> snd# X, snd# active X -> snd# X)
    (snd# active X -> snd# X, snd# mark X -> snd# X)
    (fst# active X -> fst# X, fst# active X -> fst# X)
    (fst# active X -> fst# X, fst# mark X -> fst# X)
    (head# active X -> head# X, head# active X -> head# X)
    (head# active X -> head# X, head# mark X -> head# X)
    (natsFrom# active X -> natsFrom# X, natsFrom# active X -> natsFrom# X)
    (natsFrom# active X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
    (s# active X -> s# X, s# active X -> s# X)
    (s# active X -> s# X, s# mark X -> s# X)
    (tail# active X -> tail# X, tail# active X -> tail# X)
    (tail# active X -> tail# X, tail# mark X -> tail# X)
    (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(X1, mark X2) -> U12#(X1, X2))
    (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(X1, active X2) -> U12#(X1, X2))
    (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(mark X1, X2) -> U12#(X1, X2))
    (active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X), U12#(active X1, X2) -> U12#(X1, X2))
    (tail# mark X -> tail# X, tail# mark X -> tail# X)
    (tail# mark X -> tail# X, tail# active X -> tail# X)
    (s# mark X -> s# X, s# mark X -> s# X)
    (s# mark X -> s# X, s# active X -> s# X)
    (natsFrom# mark X -> natsFrom# X, natsFrom# mark X -> natsFrom# X)
    (natsFrom# mark X -> natsFrom# X, natsFrom# active X -> natsFrom# X)
    (head# mark X -> head# X, head# mark X -> head# X)
    (head# mark X -> head# X, head# active X -> head# X)
    (fst# mark X -> fst# X, fst# mark X -> fst# X)
    (fst# mark X -> fst# X, fst# active X -> fst# X)
    (snd# mark X -> snd# X, snd# mark X -> snd# X)
    (snd# mark X -> snd# X, snd# active X -> snd# X)
    (active# and(tt(), X) -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# and(tt(), X) -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# and(tt(), X) -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (active# and(tt(), X) -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# and(tt(), X) -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# and(tt(), X) -> mark# X, mark# tt() -> active# tt())
    (active# and(tt(), X) -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (active# and(tt(), X) -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# and(tt(), X) -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# and(tt(), X) -> mark# X, mark# snd X -> mark# X)
    (active# and(tt(), X) -> mark# X, mark# snd X -> active# snd mark X)
    (active# and(tt(), X) -> mark# X, mark# snd X -> snd# mark X)
    (active# and(tt(), X) -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (active# and(tt(), X) -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# and(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# and(tt(), X) -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (active# and(tt(), X) -> mark# X, mark# fst X -> mark# X)
    (active# and(tt(), X) -> mark# X, mark# fst X -> active# fst mark X)
    (active# and(tt(), X) -> mark# X, mark# fst X -> fst# mark X)
    (active# and(tt(), X) -> mark# X, mark# head X -> mark# X)
    (active# and(tt(), X) -> mark# X, mark# head X -> active# head mark X)
    (active# and(tt(), X) -> mark# X, mark# head X -> head# mark X)
    (active# and(tt(), X) -> mark# X, mark# natsFrom X -> mark# X)
    (active# and(tt(), X) -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (active# and(tt(), X) -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (active# and(tt(), X) -> mark# X, mark# s X -> mark# X)
    (active# and(tt(), X) -> mark# X, mark# s X -> active# s mark X)
    (active# and(tt(), X) -> mark# X, mark# s X -> s# mark X)
    (active# and(tt(), X) -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (active# and(tt(), X) -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# nil() -> active# nil())
    (active# and(tt(), X) -> mark# X, mark# 0() -> active# 0())
    (active# and(tt(), X) -> mark# X, mark# tail X -> mark# X)
    (active# and(tt(), X) -> mark# X, mark# tail X -> active# tail mark X)
    (active# and(tt(), X) -> mark# X, mark# tail X -> tail# mark X)
    (active# and(tt(), X) -> mark# X, mark# take(X1, X2) -> mark# X1)
    (active# and(tt(), X) -> mark# X, mark# take(X1, X2) -> mark# X2)
    (active# and(tt(), X) -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# and(tt(), X) -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# s X -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# s X -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# s X -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (mark# s X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# s X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# s X -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# s X -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# s X -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# s X -> mark# X, mark# tt() -> active# tt())
    (mark# s X -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (mark# s X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# s X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# s X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# s X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# s X -> mark# X, mark# snd X -> mark# X)
    (mark# s X -> mark# X, mark# snd X -> active# snd mark X)
    (mark# s X -> mark# X, mark# snd X -> snd# mark X)
    (mark# s X -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (mark# s X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# s X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# s X -> mark# X, mark# and(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# s X -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# s X -> mark# X, mark# fst X -> mark# X)
    (mark# s X -> mark# X, mark# fst X -> active# fst mark X)
    (mark# s X -> mark# X, mark# fst X -> fst# mark X)
    (mark# s X -> mark# X, mark# head X -> mark# X)
    (mark# s X -> mark# X, mark# head X -> active# head mark X)
    (mark# s X -> mark# X, mark# head X -> head# mark X)
    (mark# s X -> mark# X, mark# natsFrom X -> mark# X)
    (mark# s X -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (mark# s X -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (mark# s X -> mark# X, mark# s X -> mark# X)
    (mark# s X -> mark# X, mark# s X -> active# s mark X)
    (mark# s X -> mark# X, mark# s X -> s# mark X)
    (mark# s X -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (mark# s X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# s X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# s X -> mark# X, mark# nil() -> active# nil())
    (mark# s X -> mark# X, mark# 0() -> active# 0())
    (mark# s X -> mark# X, mark# tail X -> mark# X)
    (mark# s X -> mark# X, mark# tail X -> active# tail mark X)
    (mark# s X -> mark# X, mark# tail X -> tail# mark X)
    (mark# s X -> mark# X, mark# take(X1, X2) -> mark# X1)
    (mark# s X -> mark# X, mark# take(X1, X2) -> mark# X2)
    (mark# s X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# s X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# head X -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# head X -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# head X -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (mark# head X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# head X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# head X -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# head X -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# head X -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# head X -> mark# X, mark# tt() -> active# tt())
    (mark# head X -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (mark# head X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# head X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# head X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# head X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# head X -> mark# X, mark# snd X -> mark# X)
    (mark# head X -> mark# X, mark# snd X -> active# snd mark X)
    (mark# head X -> mark# X, mark# snd X -> snd# mark X)
    (mark# head X -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (mark# head X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# head X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# head X -> mark# X, mark# and(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# head X -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# head X -> mark# X, mark# fst X -> mark# X)
    (mark# head X -> mark# X, mark# fst X -> active# fst mark X)
    (mark# head X -> mark# X, mark# fst X -> fst# mark X)
    (mark# head X -> mark# X, mark# head X -> mark# X)
    (mark# head X -> mark# X, mark# head X -> active# head mark X)
    (mark# head X -> mark# X, mark# head X -> head# mark X)
    (mark# head X -> mark# X, mark# natsFrom X -> mark# X)
    (mark# head X -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (mark# head X -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (mark# head X -> mark# X, mark# s X -> mark# X)
    (mark# head X -> mark# X, mark# s X -> active# s mark X)
    (mark# head X -> mark# X, mark# s X -> s# mark X)
    (mark# head X -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (mark# head X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# head X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# head X -> mark# X, mark# nil() -> active# nil())
    (mark# head X -> mark# X, mark# 0() -> active# 0())
    (mark# head X -> mark# X, mark# tail X -> mark# X)
    (mark# head X -> mark# X, mark# tail X -> active# tail mark X)
    (mark# head X -> mark# X, mark# tail X -> tail# mark X)
    (mark# head X -> mark# X, mark# take(X1, X2) -> mark# X1)
    (mark# head X -> mark# X, mark# take(X1, X2) -> mark# X2)
    (mark# head X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# head X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# U12(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# snd X -> mark# X, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> mark# X2)
    (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# snd X -> mark# X, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# snd X -> mark# X, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# snd X -> mark# X, mark# tt() -> active# tt())
    (mark# snd X -> mark# X, mark# pair(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# pair(X1, X2) -> mark# X2)
    (mark# snd X -> mark# X, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# cons(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# snd X -> mark# X, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# snd X -> mark# X, mark# snd X -> mark# X)
    (mark# snd X -> mark# X, mark# snd X -> active# snd mark X)
    (mark# snd X -> mark# X, mark# snd X -> snd# mark X)
    (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> mark# X2)
    (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# and(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# snd X -> mark# X, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# snd X -> mark# X, mark# fst X -> mark# X)
    (mark# snd X -> mark# X, mark# fst X -> active# fst mark X)
    (mark# snd X -> mark# X, mark# fst X -> fst# mark X)
    (mark# snd X -> mark# X, mark# head X -> mark# X)
    (mark# snd X -> mark# X, mark# head X -> active# head mark X)
    (mark# snd X -> mark# X, mark# head X -> head# mark X)
    (mark# snd X -> mark# X, mark# natsFrom X -> mark# X)
    (mark# snd X -> mark# X, mark# natsFrom X -> active# natsFrom mark X)
    (mark# snd X -> mark# X, mark# natsFrom X -> natsFrom# mark X)
    (mark# snd X -> mark# X, mark# s X -> mark# X)
    (mark# snd X -> mark# X, mark# s X -> active# s mark X)
    (mark# snd X -> mark# X, mark# s X -> s# mark X)
    (mark# snd X -> mark# X, mark# sel(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# sel(X1, X2) -> mark# X2)
    (mark# snd X -> mark# X, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# nil() -> active# nil())
    (mark# snd X -> mark# X, mark# 0() -> active# 0())
    (mark# snd X -> mark# X, mark# tail X -> mark# X)
    (mark# snd X -> mark# X, mark# tail X -> active# tail mark X)
    (mark# snd X -> mark# X, mark# tail X -> tail# mark X)
    (mark# snd X -> mark# X, mark# take(X1, X2) -> mark# X1)
    (mark# snd X -> mark# X, mark# take(X1, X2) -> mark# X2)
    (mark# snd X -> mark# X, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# snd X -> mark# X, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# sel(N, XS) -> head# afterNth(N, XS), head# mark X -> head# X)
    (active# sel(N, XS) -> head# afterNth(N, XS), head# active X -> head# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# U12(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# splitAt(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# splitAt(X1, X2) -> mark# X2)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# tt() -> active# tt())
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# pair(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# pair(X1, X2) -> mark# X2)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# cons(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# snd X -> mark# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# snd X -> active# snd mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# snd X -> snd# mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# afterNth(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# afterNth(X1, X2) -> mark# X2)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# and(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# fst X -> mark# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# fst X -> active# fst mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# fst X -> fst# mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# head X -> mark# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# head X -> active# head mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# head X -> head# mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# natsFrom X -> mark# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# natsFrom X -> active# natsFrom mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# natsFrom X -> natsFrom# mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# s X -> mark# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# s X -> active# s mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# s X -> s# mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# sel(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# sel(X1, X2) -> mark# X2)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# nil() -> active# nil())
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# 0() -> active# 0())
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# tail X -> mark# X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# tail X -> active# tail mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# tail X -> tail# mark X)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# take(X1, X2) -> mark# X1)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# take(X1, X2) -> mark# X2)
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# U12(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> mark# X2)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# tt() -> active# tt())
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> mark# X2)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# cons(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# snd X -> mark# X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# snd X -> active# snd mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# snd X -> snd# mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> mark# X2)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# and(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# fst X -> mark# X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# fst X -> active# fst mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# fst X -> fst# mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# head X -> mark# X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# head X -> active# head mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# head X -> head# mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# natsFrom X -> mark# X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# natsFrom X -> active# natsFrom mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# natsFrom X -> natsFrom# mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# s X -> mark# X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# s X -> active# s mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# s X -> s# mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> mark# X2)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# nil() -> active# nil())
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# 0() -> active# 0())
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# tail X -> mark# X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# tail X -> active# tail mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# tail X -> tail# mark X)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> mark# X1)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> mark# X2)
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# snd pair(X, Y) -> mark# Y)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# and(tt(), X) -> mark# X)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# fst pair(X, Y) -> mark# X)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# head cons(N, XS) -> mark# N)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> natsFrom# s N)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# natsFrom N -> s# N)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# tail cons(N, XS) -> mark# XS)
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# cons(X1, X2) -> active# cons(mark X1, X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# take(X1, X2) -> mark# X2, mark# U12(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# take(X1, X2) -> mark# X2, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# take(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# take(X1, X2) -> mark# X2, mark# tt() -> active# tt())
    (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# take(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# take(X1, X2) -> mark# X2, mark# snd X -> mark# X)
    (mark# take(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X)
    (mark# take(X1, X2) -> mark# X2, mark# snd X -> snd# mark X)
    (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# and(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# take(X1, X2) -> mark# X2, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# take(X1, X2) -> mark# X2, mark# fst X -> mark# X)
    (mark# take(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X)
    (mark# take(X1, X2) -> mark# X2, mark# fst X -> fst# mark X)
    (mark# take(X1, X2) -> mark# X2, mark# head X -> mark# X)
    (mark# take(X1, X2) -> mark# X2, mark# head X -> active# head mark X)
    (mark# take(X1, X2) -> mark# X2, mark# head X -> head# mark X)
    (mark# take(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X)
    (mark# take(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X)
    (mark# take(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X)
    (mark# take(X1, X2) -> mark# X2, mark# s X -> mark# X)
    (mark# take(X1, X2) -> mark# X2, mark# s X -> active# s mark X)
    (mark# take(X1, X2) -> mark# X2, mark# s X -> s# mark X)
    (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# nil() -> active# nil())
    (mark# take(X1, X2) -> mark# X2, mark# 0() -> active# 0())
    (mark# take(X1, X2) -> mark# X2, mark# tail X -> mark# X)
    (mark# take(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X)
    (mark# take(X1, X2) -> mark# X2, mark# tail X -> tail# mark X)
    (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# U12(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# afterNth(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# afterNth(X1, X2) -> mark# X2, mark# tt() -> active# tt())
    (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# snd X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# snd X -> snd# mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# and(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# fst X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# fst X -> fst# mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# head X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# head X -> active# head mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# head X -> head# mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# s X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# s X -> active# s mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# s X -> s# mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# nil() -> active# nil())
    (mark# afterNth(X1, X2) -> mark# X2, mark# 0() -> active# 0())
    (mark# afterNth(X1, X2) -> mark# X2, mark# tail X -> mark# X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# tail X -> tail# mark X)
    (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1)
    (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2)
    (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# afterNth(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# U12(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# splitAt(X1, X2) -> mark# X2, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# splitAt(X1, X2) -> mark# X2, mark# tt() -> active# tt())
    (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# cons(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# snd X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# snd X -> active# snd mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# snd X -> snd# mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# and(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# fst X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# fst X -> active# fst mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# fst X -> fst# mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# head X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# head X -> active# head mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# head X -> head# mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# natsFrom X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# natsFrom X -> active# natsFrom mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# natsFrom X -> natsFrom# mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# s X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# s X -> active# s mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# s X -> s# mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# nil() -> active# nil())
    (mark# splitAt(X1, X2) -> mark# X2, mark# 0() -> active# 0())
    (mark# splitAt(X1, X2) -> mark# X2, mark# tail X -> mark# X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# tail X -> active# tail mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# tail X -> tail# mark X)
    (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X1)
    (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> mark# X2)
    (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# splitAt(X1, X2) -> mark# X2, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# U12(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> mark# X2)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tt() -> active# tt())
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> mark# X2)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# cons(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# snd X -> mark# X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# snd X -> active# snd mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# snd X -> snd# mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> mark# X2)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# and(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# fst X -> mark# X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# fst X -> active# fst mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# fst X -> fst# mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# head X -> mark# X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# head X -> active# head mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# head X -> head# mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# natsFrom X -> mark# X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# natsFrom X -> active# natsFrom mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# natsFrom X -> natsFrom# mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# s X -> mark# X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# s X -> active# s mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# s X -> s# mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> mark# X2)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# nil() -> active# nil())
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# 0() -> active# 0())
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tail X -> mark# X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tail X -> active# tail mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# tail X -> tail# mark X)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> mark# X1)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> mark# X2)
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# sel(N, XS) -> mark# head afterNth(N, XS), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# U12(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> mark# X2)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tt() -> active# tt())
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> mark# X2)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# cons(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# snd X -> mark# X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# snd X -> active# snd mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# snd X -> snd# mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> mark# X2)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# and(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# fst X -> mark# X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# fst X -> active# fst mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# fst X -> fst# mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# head X -> mark# X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# head X -> active# head mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# head X -> head# mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# natsFrom X -> mark# X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# natsFrom X -> active# natsFrom mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# natsFrom X -> natsFrom# mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# s X -> mark# X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# s X -> active# s mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# s X -> s# mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> mark# X2)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# nil() -> active# nil())
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# 0() -> active# 0())
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tail X -> mark# X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tail X -> active# tail mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# tail X -> tail# mark X)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> mark# X1)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> mark# X2)
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# afterNth(N, XS) -> mark# snd splitAt(N, XS), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# s X -> active# s mark X, active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# s X -> active# s mark X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# s X -> active# s mark X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# s X -> active# s mark X, active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# s X -> active# s mark X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# s X -> active# s mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# s X -> active# s mark X, active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# s X -> active# s mark X, active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# s X -> active# s mark X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# s X -> active# s mark X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# s X -> active# s mark X, active# snd pair(X, Y) -> mark# Y)
    (mark# s X -> active# s mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# s X -> active# s mark X, active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# s X -> active# s mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# s X -> active# s mark X, active# and(tt(), X) -> mark# X)
    (mark# s X -> active# s mark X, active# fst pair(X, Y) -> mark# X)
    (mark# s X -> active# s mark X, active# head cons(N, XS) -> mark# N)
    (mark# s X -> active# s mark X, active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# s X -> active# s mark X, active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# s X -> active# s mark X, active# natsFrom N -> natsFrom# s N)
    (mark# s X -> active# s mark X, active# natsFrom N -> s# N)
    (mark# s X -> active# s mark X, active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# s X -> active# s mark X, active# sel(N, XS) -> afterNth#(N, XS))
    (mark# s X -> active# s mark X, active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# s X -> active# s mark X, active# tail cons(N, XS) -> mark# XS)
    (mark# s X -> active# s mark X, active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# s X -> active# s mark X, active# take(N, XS) -> splitAt#(N, XS))
    (mark# s X -> active# s mark X, active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# head X -> active# head mark X, active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# head X -> active# head mark X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# head X -> active# head mark X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# head X -> active# head mark X, active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# head X -> active# head mark X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# head X -> active# head mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# head X -> active# head mark X, active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# head X -> active# head mark X, active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# head X -> active# head mark X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# head X -> active# head mark X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# head X -> active# head mark X, active# snd pair(X, Y) -> mark# Y)
    (mark# head X -> active# head mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# head X -> active# head mark X, active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# head X -> active# head mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# head X -> active# head mark X, active# and(tt(), X) -> mark# X)
    (mark# head X -> active# head mark X, active# fst pair(X, Y) -> mark# X)
    (mark# head X -> active# head mark X, active# head cons(N, XS) -> mark# N)
    (mark# head X -> active# head mark X, active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# head X -> active# head mark X, active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# head X -> active# head mark X, active# natsFrom N -> natsFrom# s N)
    (mark# head X -> active# head mark X, active# natsFrom N -> s# N)
    (mark# head X -> active# head mark X, active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# head X -> active# head mark X, active# sel(N, XS) -> afterNth#(N, XS))
    (mark# head X -> active# head mark X, active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# head X -> active# head mark X, active# tail cons(N, XS) -> mark# XS)
    (mark# head X -> active# head mark X, active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# head X -> active# head mark X, active# take(N, XS) -> splitAt#(N, XS))
    (mark# head X -> active# head mark X, active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# snd X -> active# snd mark X, active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# snd X -> active# snd mark X, active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# snd X -> active# snd mark X, active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# snd X -> active# snd mark X, active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# snd X -> active# snd mark X, active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# snd X -> active# snd mark X, active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# snd X -> active# snd mark X, active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# snd X -> active# snd mark X, active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# snd X -> active# snd mark X, active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# snd X -> active# snd mark X, active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# snd X -> active# snd mark X, active# snd pair(X, Y) -> mark# Y)
    (mark# snd X -> active# snd mark X, active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# snd X -> active# snd mark X, active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# snd X -> active# snd mark X, active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# snd X -> active# snd mark X, active# and(tt(), X) -> mark# X)
    (mark# snd X -> active# snd mark X, active# fst pair(X, Y) -> mark# X)
    (mark# snd X -> active# snd mark X, active# head cons(N, XS) -> mark# N)
    (mark# snd X -> active# snd mark X, active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# snd X -> active# snd mark X, active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# snd X -> active# snd mark X, active# natsFrom N -> natsFrom# s N)
    (mark# snd X -> active# snd mark X, active# natsFrom N -> s# N)
    (mark# snd X -> active# snd mark X, active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# snd X -> active# snd mark X, active# sel(N, XS) -> afterNth#(N, XS))
    (mark# snd X -> active# snd mark X, active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# snd X -> active# snd mark X, active# tail cons(N, XS) -> mark# XS)
    (mark# snd X -> active# snd mark X, active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# snd X -> active# snd mark X, active# take(N, XS) -> splitAt#(N, XS))
    (mark# snd X -> active# snd mark X, active# take(N, XS) -> fst# splitAt(N, XS))
    (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, mark X2) -> pair#(X1, X2))
    (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(X1, active X2) -> pair#(X1, X2))
    (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(mark X1, X2) -> pair#(X1, X2))
    (active# splitAt(0(), XS) -> pair#(nil(), XS), pair#(active X1, X2) -> pair#(X1, X2))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# snd pair(X, Y) -> mark# Y)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# and(tt(), X) -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# fst pair(X, Y) -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# head cons(N, XS) -> mark# N)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# natsFrom N -> natsFrom# s N)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# natsFrom N -> s# N)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# tail cons(N, XS) -> mark# XS)
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# take(N, XS) -> splitAt#(N, XS))
    (mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4), active# take(N, XS) -> fst# splitAt(N, XS))
    (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
    (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(X1, active X2) -> afterNth#(X1, X2))
    (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
    (active# sel(N, XS) -> afterNth#(N, XS), afterNth#(active X1, 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#(X1, active 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#(active X1, X2) -> splitAt#(X1, X2))
    (mark# tail X -> tail# mark X, tail# mark X -> tail# X)
    (mark# tail X -> tail# mark X, tail# active X -> tail# X)
    (mark# natsFrom X -> natsFrom# mark X, natsFrom# mark X -> natsFrom# X)
    (mark# natsFrom X -> natsFrom# mark X, natsFrom# active X -> natsFrom# X)
    (mark# fst X -> fst# mark X, fst# mark X -> fst# X)
    (mark# fst X -> fst# mark X, fst# active X -> fst# X)
    (active# natsFrom N -> s# N, s# mark X -> s# X)
    (active# natsFrom N -> s# N, s# active X -> s# X)
    (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(X1, mark X2) -> take#(X1, X2))
    (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(X1, active X2) -> take#(X1, X2))
    (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(mark X1, X2) -> take#(X1, X2))
    (mark# take(X1, X2) -> take#(mark X1, mark X2), take#(active X1, X2) -> take#(X1, X2))
    (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
    (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(X1, active X2) -> afterNth#(X1, X2))
    (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
    (mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2), afterNth#(active X1, X2) -> afterNth#(X1, X2))
    (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
    (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(X1, active X2) -> splitAt#(X1, X2))
    (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
    (mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2), splitAt#(active X1, X2) -> splitAt#(X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# U12(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# U12(X1, X2) -> U12#(mark X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> mark# X2)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# U11(X1, X2, X3, X4) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tt() -> active# tt())
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> mark# X2)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# cons(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# cons(X1, X2) -> cons#(mark X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# snd X -> mark# X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# snd X -> active# snd mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# snd X -> snd# mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> mark# X2)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# and(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# and(X1, X2) -> active# and(mark X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# and(X1, X2) -> and#(mark X1, X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# fst X -> mark# X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# fst X -> active# fst mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# fst X -> fst# mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# head X -> mark# X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# head X -> active# head mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# head X -> head# mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# natsFrom X -> mark# X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# natsFrom X -> active# natsFrom mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# natsFrom X -> natsFrom# mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# s X -> mark# X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# s X -> active# s mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# s X -> s# mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> mark# X2)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# nil() -> active# nil())
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# 0() -> active# 0())
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tail X -> mark# X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tail X -> active# tail mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# tail X -> tail# mark X)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> mark# X1)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> mark# X2)
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (active# natsFrom N -> mark# cons(N, natsFrom s N), mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# snd pair(X, Y) -> mark# Y)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# and(tt(), X) -> mark# X)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# fst pair(X, Y) -> mark# X)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# head cons(N, XS) -> mark# N)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> natsFrom# s N)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# natsFrom N -> s# N)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS)
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# sel(X1, X2) -> active# sel(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# snd pair(X, Y) -> mark# Y)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# and(tt(), X) -> mark# X)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# fst pair(X, Y) -> mark# X)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# head cons(N, XS) -> mark# N)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> natsFrom# s N)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# natsFrom N -> s# N)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# tail cons(N, XS) -> mark# XS)
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# take(N, XS) -> splitAt#(N, XS))
    (mark# pair(X1, X2) -> active# pair(mark X1, mark X2), active# take(N, XS) -> fst# splitAt(N, XS))
    (take#(active X1, X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
    (take#(active X1, X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2))
    (take#(active X1, X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2))
    (take#(active X1, X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2))
    (take#(X1, active X2) -> take#(X1, X2), take#(X1, mark X2) -> take#(X1, X2))
    (take#(X1, active X2) -> take#(X1, X2), take#(X1, active X2) -> take#(X1, X2))
    (take#(X1, active X2) -> take#(X1, X2), take#(mark X1, X2) -> take#(X1, X2))
    (take#(X1, active X2) -> take#(X1, X2), take#(active X1, X2) -> take#(X1, X2))
    (sel#(active X1, X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
    (sel#(active X1, X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2))
    (sel#(active X1, X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
    (sel#(active X1, X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2))
    (sel#(X1, active X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
    (sel#(X1, active X2) -> sel#(X1, X2), sel#(X1, active X2) -> sel#(X1, X2))
    (sel#(X1, active X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
    (sel#(X1, active X2) -> sel#(X1, X2), sel#(active X1, X2) -> sel#(X1, X2))
    (and#(active X1, X2) -> and#(X1, X2), and#(X1, mark X2) -> and#(X1, X2))
    (and#(active X1, X2) -> and#(X1, X2), and#(X1, active X2) -> and#(X1, X2))
    (and#(active X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
    (and#(active X1, X2) -> and#(X1, X2), and#(active X1, X2) -> and#(X1, X2))
    (and#(X1, active X2) -> and#(X1, X2), and#(X1, mark X2) -> and#(X1, X2))
    (and#(X1, active X2) -> and#(X1, X2), and#(X1, active X2) -> and#(X1, X2))
    (and#(X1, active X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
    (and#(X1, active X2) -> and#(X1, X2), and#(active X1, X2) -> and#(X1, X2))
    (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
    (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2))
    (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
    (afterNth#(active X1, X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2))
    (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(X1, mark X2) -> afterNth#(X1, X2))
    (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(X1, active X2) -> afterNth#(X1, X2))
    (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(mark X1, X2) -> afterNth#(X1, X2))
    (afterNth#(X1, active X2) -> afterNth#(X1, X2), afterNth#(active X1, X2) -> afterNth#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (cons#(active X1, X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (cons#(X1, active X2) -> cons#(X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (pair#(active X1, X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
    (pair#(active X1, X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2))
    (pair#(active X1, X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
    (pair#(active X1, X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2))
    (pair#(X1, active X2) -> pair#(X1, X2), pair#(X1, mark X2) -> pair#(X1, X2))
    (pair#(X1, active X2) -> pair#(X1, X2), pair#(X1, active X2) -> pair#(X1, X2))
    (pair#(X1, active X2) -> pair#(X1, X2), pair#(mark X1, X2) -> pair#(X1, X2))
    (pair#(X1, active X2) -> pair#(X1, X2), pair#(active X1, X2) -> pair#(X1, X2))
    (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(X1, mark X2) -> pair#(X1, X2))
    (active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS), pair#(X1, active 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#(active X1, 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#(X1, active X2) -> splitAt#(X1, X2))
    (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
    (splitAt#(mark X1, X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2))
    (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, mark X2) -> splitAt#(X1, X2))
    (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(X1, active X2) -> splitAt#(X1, X2))
    (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(mark X1, X2) -> splitAt#(X1, X2))
    (splitAt#(X1, mark X2) -> splitAt#(X1, X2), splitAt#(active X1, X2) -> splitAt#(X1, X2))
    (U12#(mark X1, X2) -> U12#(X1, X2), U12#(X1, mark X2) -> U12#(X1, X2))
    (U12#(mark X1, X2) -> U12#(X1, X2), U12#(X1, active X2) -> U12#(X1, X2))
    (U12#(mark X1, X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
    (U12#(mark X1, X2) -> U12#(X1, X2), U12#(active X1, X2) -> U12#(X1, X2))
    (U12#(X1, mark X2) -> U12#(X1, X2), U12#(X1, mark X2) -> U12#(X1, X2))
    (U12#(X1, mark X2) -> U12#(X1, X2), U12#(X1, active X2) -> U12#(X1, X2))
    (U12#(X1, mark X2) -> U12#(X1, X2), U12#(mark X1, X2) -> U12#(X1, X2))
    (U12#(X1, mark X2) -> U12#(X1, X2), U12#(active X1, X2) -> U12#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(X1, mark X2) -> cons#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(X1, active X2) -> cons#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
    (mark# cons(X1, X2) -> cons#(mark X1, X2), cons#(active X1, X2) -> cons#(X1, X2))
    (mark# 0() -> active# 0(), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# 0() -> active# 0(), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# 0() -> active# 0(), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# 0() -> active# 0(), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# 0() -> active# 0(), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# 0() -> active# 0(), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# 0() -> active# 0(), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# 0() -> active# 0(), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# 0() -> active# 0(), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# 0() -> active# 0(), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# 0() -> active# 0(), active# snd pair(X, Y) -> mark# Y)
    (mark# 0() -> active# 0(), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# 0() -> active# 0(), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# 0() -> active# 0(), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# 0() -> active# 0(), active# and(tt(), X) -> mark# X)
    (mark# 0() -> active# 0(), active# fst pair(X, Y) -> mark# X)
    (mark# 0() -> active# 0(), active# head cons(N, XS) -> mark# N)
    (mark# 0() -> active# 0(), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# 0() -> active# 0(), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# 0() -> active# 0(), active# natsFrom N -> natsFrom# s N)
    (mark# 0() -> active# 0(), active# natsFrom N -> s# N)
    (mark# 0() -> active# 0(), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# 0() -> active# 0(), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# 0() -> active# 0(), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# 0() -> active# 0(), active# tail cons(N, XS) -> mark# XS)
    (mark# 0() -> active# 0(), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# 0() -> active# 0(), active# take(N, XS) -> splitAt#(N, XS))
    (mark# 0() -> active# 0(), active# take(N, XS) -> fst# splitAt(N, XS))
    (mark# tt() -> active# tt(), active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS))
    (mark# tt() -> active# tt(), active# U12(pair(YS, ZS), X) -> pair#(cons(X, YS), ZS))
    (mark# tt() -> active# tt(), active# U12(pair(YS, ZS), X) -> cons#(X, YS))
    (mark# tt() -> active# tt(), active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS))
    (mark# tt() -> active# tt(), active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS))
    (mark# tt() -> active# tt(), active# splitAt(0(), XS) -> mark# pair(nil(), XS))
    (mark# tt() -> active# tt(), active# splitAt(0(), XS) -> pair#(nil(), XS))
    (mark# tt() -> active# tt(), active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X))
    (mark# tt() -> active# tt(), active# U11(tt(), N, X, XS) -> U12#(splitAt(N, XS), X))
    (mark# tt() -> active# tt(), active# U11(tt(), N, X, XS) -> splitAt#(N, XS))
    (mark# tt() -> active# tt(), active# snd pair(X, Y) -> mark# Y)
    (mark# tt() -> active# tt(), active# afterNth(N, XS) -> mark# snd splitAt(N, XS))
    (mark# tt() -> active# tt(), active# afterNth(N, XS) -> splitAt#(N, XS))
    (mark# tt() -> active# tt(), active# afterNth(N, XS) -> snd# splitAt(N, XS))
    (mark# tt() -> active# tt(), active# and(tt(), X) -> mark# X)
    (mark# tt() -> active# tt(), active# fst pair(X, Y) -> mark# X)
    (mark# tt() -> active# tt(), active# head cons(N, XS) -> mark# N)
    (mark# tt() -> active# tt(), active# natsFrom N -> mark# cons(N, natsFrom s N))
    (mark# tt() -> active# tt(), active# natsFrom N -> cons#(N, natsFrom s N))
    (mark# tt() -> active# tt(), active# natsFrom N -> natsFrom# s N)
    (mark# tt() -> active# tt(), active# natsFrom N -> s# N)
    (mark# tt() -> active# tt(), active# sel(N, XS) -> mark# head afterNth(N, XS))
    (mark# tt() -> active# tt(), active# sel(N, XS) -> afterNth#(N, XS))
    (mark# tt() -> active# tt(), active# sel(N, XS) -> head# afterNth(N, XS))
    (mark# tt() -> active# tt(), active# tail cons(N, XS) -> mark# XS)
    (mark# tt() -> active# tt(), active# take(N, XS) -> mark# fst splitAt(N, XS))
    (mark# tt() -> active# tt(), active# take(N, XS) -> splitAt#(N, XS))
    (mark# tt() -> active# tt(), active# take(N, XS) -> fst# splitAt(N, XS))
    (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (active# splitAt(s N, cons(X, XS)) -> U11#(tt(), N, X, XS), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (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#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, 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))
    (U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4), U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4))
    (mark# take(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# take(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# take(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# take(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# take(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# take(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# take(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# take(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# take(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# take(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# take(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# take(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# take(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# take(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# take(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# take(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# take(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# take(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# take(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# take(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# take(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# take(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# take(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# take(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# take(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# take(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# and(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# and(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# and(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# and(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# and(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# and(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# and(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# and(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# and(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# and(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# and(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# and(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# and(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# and(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# and(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# and(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# and(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# and(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# and(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# and(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# and(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# and(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# and(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# and(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# and(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# and(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# and(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# and(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# and(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# and(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# and(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# and(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# and(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# and(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# and(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# and(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# cons(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# cons(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# cons(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# cons(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# cons(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# cons(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# cons(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# cons(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# cons(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# cons(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# cons(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# cons(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# tt() -> active# tt())
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# snd X -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# fst X -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# head X -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# head X -> active# head mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# head X -> head# mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# s X -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# s X -> active# s mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# s X -> s# mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# nil() -> active# nil())
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# 0() -> active# 0())
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# tail X -> mark# X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# U11(X1, X2, X3, X4) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# U12(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# U12(X1, X2) -> U12#(mark X1, X2))
    (mark# U12(X1, X2) -> mark# X1, mark# U12(X1, X2) -> active# U12(mark X1, X2))
    (mark# U12(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> mark# X2)
    (mark# U12(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> splitAt#(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4))
    (mark# U12(X1, X2) -> mark# X1, mark# U11(X1, X2, X3, X4) -> U11#(mark X1, X2, X3, X4))
    (mark# U12(X1, X2) -> mark# X1, mark# tt() -> active# tt())
    (mark# U12(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# pair(X1, X2) -> mark# X2)
    (mark# U12(X1, X2) -> mark# X1, mark# pair(X1, X2) -> active# pair(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# pair(X1, X2) -> pair#(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# cons(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# cons(X1, X2) -> active# cons(mark X1, X2))
    (mark# U12(X1, X2) -> mark# X1, mark# cons(X1, X2) -> cons#(mark X1, X2))
    (mark# U12(X1, X2) -> mark# X1, mark# snd X -> mark# X)
    (mark# U12(X1, X2) -> mark# X1, mark# snd X -> active# snd mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# snd X -> snd# mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> mark# X2)
    (mark# U12(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# afterNth(X1, X2) -> afterNth#(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# and(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# and(X1, X2) -> active# and(mark X1, X2))
    (mark# U12(X1, X2) -> mark# X1, mark# and(X1, X2) -> and#(mark X1, X2))
    (mark# U12(X1, X2) -> mark# X1, mark# fst X -> mark# X)
    (mark# U12(X1, X2) -> mark# X1, mark# fst X -> active# fst mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# fst X -> fst# mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# head X -> mark# X)
    (mark# U12(X1, X2) -> mark# X1, mark# head X -> active# head mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# head X -> head# mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# natsFrom X -> mark# X)
    (mark# U12(X1, X2) -> mark# X1, mark# natsFrom X -> active# natsFrom mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# natsFrom X -> natsFrom# mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# s X -> mark# X)
    (mark# U12(X1, X2) -> mark# X1, mark# s X -> active# s mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# s X -> s# mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# sel(X1, X2) -> mark# X2)
    (mark# U12(X1, X2) -> mark# X1, mark# sel(X1, X2) -> active# sel(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# sel(X1, X2) -> sel#(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# nil() -> active# nil())
    (mark# U12(X1, X2) -> mark# X1, mark# 0() -> active# 0())
    (mark# U12(X1, X2) -> mark# X1, mark# tail X -> mark# X)
    (mark# U12(X1, X2) -> mark# X1, mark# tail X -> active# tail mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# tail X -> tail# mark X)
    (mark# U12(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X1)
    (mark# U12(X1, X2) -> mark# X1, mark# take(X1, X2) -> mark# X2)
    (mark# U12(X1, X2) -> mark# X1, mark# take(X1, X2) -> active# take(mark X1, mark X2))
    (mark# U12(X1, X2) -> mark# X1, mark# take(X1, X2) -> take#(mark X1, mark X2))
   }
   STATUS:
    arrows: 0.854429
    SCCS (16):
     Scc:
      {                mark# U12(X1, X2) -> mark# X1,
                       mark# U12(X1, X2) -> active# U12(mark X1, X2),
                   mark# splitAt(X1, X2) -> mark# X1,
                   mark# splitAt(X1, X2) -> mark# X2,
                   mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2),
               mark# U11(X1, X2, X3, X4) -> mark# X1,
               mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4),
                              mark# tt() -> active# tt(),
                      mark# pair(X1, X2) -> mark# X1,
                      mark# pair(X1, X2) -> mark# X2,
                      mark# pair(X1, X2) -> active# pair(mark X1, mark X2),
                      mark# cons(X1, X2) -> mark# X1,
                      mark# cons(X1, X2) -> active# cons(mark X1, X2),
                             mark# snd X -> mark# X,
                             mark# snd X -> active# snd mark X,
                  mark# afterNth(X1, X2) -> mark# X1,
                  mark# afterNth(X1, X2) -> mark# X2,
                  mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2),
                       mark# and(X1, X2) -> mark# X1,
                       mark# and(X1, X2) -> active# and(mark X1, X2),
                             mark# fst X -> mark# X,
                             mark# fst X -> active# fst mark X,
                            mark# head X -> mark# X,
                            mark# head X -> active# head mark X,
                        mark# natsFrom X -> mark# X,
                        mark# natsFrom X -> active# natsFrom mark X,
                               mark# s X -> mark# X,
                               mark# s X -> active# s mark X,
                       mark# sel(X1, X2) -> mark# X1,
                       mark# sel(X1, X2) -> mark# X2,
                       mark# sel(X1, X2) -> active# sel(mark X1, mark X2),
                             mark# nil() -> active# nil(),
                               mark# 0() -> active# 0(),
                            mark# tail X -> mark# X,
                            mark# tail X -> active# tail mark X,
                      mark# take(X1, X2) -> mark# X1,
                      mark# take(X1, X2) -> mark# X2,
                      mark# take(X1, X2) -> active# take(mark X1, mark X2),
            active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS),
       active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS),
                active# splitAt(0(), XS) -> mark# pair(nil(), XS),
             active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X),
                  active# snd pair(X, Y) -> mark# Y,
                 active# afterNth(N, XS) -> mark# snd splitAt(N, XS),
                    active# and(tt(), X) -> mark# X,
                  active# fst pair(X, Y) -> mark# X,
                active# head cons(N, XS) -> mark# N,
                      active# natsFrom N -> mark# cons(N, natsFrom s N),
                      active# sel(N, XS) -> mark# head afterNth(N, XS),
                active# tail cons(N, XS) -> mark# XS,
                     active# take(N, XS) -> mark# fst splitAt(N, XS)}
     Scc:
      {  take#(X1, mark X2) -> take#(X1, X2),
       take#(X1, active X2) -> take#(X1, X2),
         take#(mark X1, X2) -> take#(X1, X2),
       take#(active X1, X2) -> take#(X1, X2)}
     Scc:
      {  tail# mark X -> tail# X,
       tail# active X -> tail# X}
     Scc:
      {  sel#(X1, mark X2) -> sel#(X1, X2),
       sel#(X1, active X2) -> sel#(X1, X2),
         sel#(mark X1, X2) -> sel#(X1, X2),
       sel#(active X1, X2) -> sel#(X1, X2)}
     Scc:
      {  head# mark X -> head# X,
       head# active X -> head# X}
     Scc:
      {  s# mark X -> s# X,
       s# active X -> s# X}
     Scc:
      {  natsFrom# mark X -> natsFrom# X,
       natsFrom# active X -> natsFrom# X}
     Scc:
      {  fst# mark X -> fst# X,
       fst# active X -> fst# X}
     Scc:
      {  and#(X1, mark X2) -> and#(X1, X2),
       and#(X1, active X2) -> and#(X1, X2),
         and#(mark X1, X2) -> and#(X1, X2),
       and#(active X1, X2) -> and#(X1, X2)}
     Scc:
      {  afterNth#(X1, mark X2) -> afterNth#(X1, X2),
       afterNth#(X1, active X2) -> afterNth#(X1, X2),
         afterNth#(mark X1, X2) -> afterNth#(X1, X2),
       afterNth#(active X1, X2) -> afterNth#(X1, X2)}
     Scc:
      {  snd# mark X -> snd# X,
       snd# active X -> snd# X}
     Scc:
      {  U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4),
       U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4),
         U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4),
       U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4),
         U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4),
       U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4),
         U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
       U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4)}
     Scc:
      {  cons#(X1, mark X2) -> cons#(X1, X2),
       cons#(X1, active X2) -> cons#(X1, X2),
         cons#(mark X1, X2) -> cons#(X1, X2),
       cons#(active X1, X2) -> cons#(X1, X2)}
     Scc:
      {  pair#(X1, mark X2) -> pair#(X1, X2),
       pair#(X1, active X2) -> pair#(X1, X2),
         pair#(mark X1, X2) -> pair#(X1, X2),
       pair#(active X1, X2) -> pair#(X1, X2)}
     Scc:
      {  splitAt#(X1, mark X2) -> splitAt#(X1, X2),
       splitAt#(X1, active X2) -> splitAt#(X1, X2),
         splitAt#(mark X1, X2) -> splitAt#(X1, X2),
       splitAt#(active X1, X2) -> splitAt#(X1, X2)}
     Scc:
      {  U12#(X1, mark X2) -> U12#(X1, X2),
       U12#(X1, active X2) -> U12#(X1, X2),
         U12#(mark X1, X2) -> U12#(X1, X2),
       U12#(active X1, X2) -> U12#(X1, X2)}
     
     SCC (51):
      Strict:
       {                mark# U12(X1, X2) -> mark# X1,
                        mark# U12(X1, X2) -> active# U12(mark X1, X2),
                    mark# splitAt(X1, X2) -> mark# X1,
                    mark# splitAt(X1, X2) -> mark# X2,
                    mark# splitAt(X1, X2) -> active# splitAt(mark X1, mark X2),
                mark# U11(X1, X2, X3, X4) -> mark# X1,
                mark# U11(X1, X2, X3, X4) -> active# U11(mark X1, X2, X3, X4),
                               mark# tt() -> active# tt(),
                       mark# pair(X1, X2) -> mark# X1,
                       mark# pair(X1, X2) -> mark# X2,
                       mark# pair(X1, X2) -> active# pair(mark X1, mark X2),
                       mark# cons(X1, X2) -> mark# X1,
                       mark# cons(X1, X2) -> active# cons(mark X1, X2),
                              mark# snd X -> mark# X,
                              mark# snd X -> active# snd mark X,
                   mark# afterNth(X1, X2) -> mark# X1,
                   mark# afterNth(X1, X2) -> mark# X2,
                   mark# afterNth(X1, X2) -> active# afterNth(mark X1, mark X2),
                        mark# and(X1, X2) -> mark# X1,
                        mark# and(X1, X2) -> active# and(mark X1, X2),
                              mark# fst X -> mark# X,
                              mark# fst X -> active# fst mark X,
                             mark# head X -> mark# X,
                             mark# head X -> active# head mark X,
                         mark# natsFrom X -> mark# X,
                         mark# natsFrom X -> active# natsFrom mark X,
                                mark# s X -> mark# X,
                                mark# s X -> active# s mark X,
                        mark# sel(X1, X2) -> mark# X1,
                        mark# sel(X1, X2) -> mark# X2,
                        mark# sel(X1, X2) -> active# sel(mark X1, mark X2),
                              mark# nil() -> active# nil(),
                                mark# 0() -> active# 0(),
                             mark# tail X -> mark# X,
                             mark# tail X -> active# tail mark X,
                       mark# take(X1, X2) -> mark# X1,
                       mark# take(X1, X2) -> mark# X2,
                       mark# take(X1, X2) -> active# take(mark X1, mark X2),
             active# U12(pair(YS, ZS), X) -> mark# pair(cons(X, YS), ZS),
        active# splitAt(s N, cons(X, XS)) -> mark# U11(tt(), N, X, XS),
                 active# splitAt(0(), XS) -> mark# pair(nil(), XS),
              active# U11(tt(), N, X, XS) -> mark# U12(splitAt(N, XS), X),
                   active# snd pair(X, Y) -> mark# Y,
                  active# afterNth(N, XS) -> mark# snd splitAt(N, XS),
                     active# and(tt(), X) -> mark# X,
                   active# fst pair(X, Y) -> mark# X,
                 active# head cons(N, XS) -> mark# N,
                       active# natsFrom N -> mark# cons(N, natsFrom s N),
                       active# sel(N, XS) -> mark# head afterNth(N, XS),
                 active# tail cons(N, XS) -> mark# XS,
                      active# take(N, XS) -> mark# fst splitAt(N, XS)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  take#(X1, mark X2) -> take#(X1, X2),
        take#(X1, active X2) -> take#(X1, X2),
          take#(mark X1, X2) -> take#(X1, X2),
        take#(active X1, X2) -> take#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (2):
      Strict:
       {  tail# mark X -> tail# X,
        tail# active X -> tail# X}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  sel#(X1, mark X2) -> sel#(X1, X2),
        sel#(X1, active X2) -> sel#(X1, X2),
          sel#(mark X1, X2) -> sel#(X1, X2),
        sel#(active X1, X2) -> sel#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     
     
     
     
     
     
     SCC (2):
      Strict:
       {  head# mark X -> head# X,
        head# active X -> head# X}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (2):
      Strict:
       {  s# mark X -> s# X,
        s# active X -> s# X}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (2):
      Strict:
       {  natsFrom# mark X -> natsFrom# X,
        natsFrom# active X -> natsFrom# X}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     
     SCC (2):
      Strict:
       {  fst# mark X -> fst# X,
        fst# active X -> fst# X}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  and#(X1, mark X2) -> and#(X1, X2),
        and#(X1, active X2) -> and#(X1, X2),
          and#(mark X1, X2) -> and#(X1, X2),
        and#(active X1, X2) -> and#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  afterNth#(X1, mark X2) -> afterNth#(X1, X2),
        afterNth#(X1, active X2) -> afterNth#(X1, X2),
          afterNth#(mark X1, X2) -> afterNth#(X1, X2),
        afterNth#(active X1, X2) -> afterNth#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     
     SCC (2):
      Strict:
       {  snd# mark X -> snd# X,
        snd# active X -> snd# X}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     
     
     
     
     
     
     
     SCC (8):
      Strict:
       {  U11#(X1, X2, X3, mark X4) -> U11#(X1, X2, X3, X4),
        U11#(X1, X2, X3, active X4) -> U11#(X1, X2, X3, X4),
          U11#(X1, X2, mark X3, X4) -> U11#(X1, X2, X3, X4),
        U11#(X1, X2, active X3, X4) -> U11#(X1, X2, X3, X4),
          U11#(X1, mark X2, X3, X4) -> U11#(X1, X2, X3, X4),
        U11#(X1, active X2, X3, X4) -> U11#(X1, X2, X3, X4),
          U11#(mark X1, X2, X3, X4) -> U11#(X1, X2, X3, X4),
        U11#(active X1, X2, X3, X4) -> U11#(X1, X2, X3, X4)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  cons#(X1, mark X2) -> cons#(X1, X2),
        cons#(X1, active X2) -> cons#(X1, X2),
          cons#(mark X1, X2) -> cons#(X1, X2),
        cons#(active X1, X2) -> cons#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  pair#(X1, mark X2) -> pair#(X1, X2),
        pair#(X1, active X2) -> pair#(X1, X2),
          pair#(mark X1, X2) -> pair#(X1, X2),
        pair#(active X1, X2) -> pair#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  splitAt#(X1, mark X2) -> splitAt#(X1, X2),
        splitAt#(X1, active X2) -> splitAt#(X1, X2),
          splitAt#(mark X1, X2) -> splitAt#(X1, X2),
        splitAt#(active X1, X2) -> splitAt#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open
     
     SCC (4):
      Strict:
       {  U12#(X1, mark X2) -> U12#(X1, X2),
        U12#(X1, active X2) -> U12#(X1, X2),
          U12#(mark X1, X2) -> U12#(X1, X2),
        U12#(active X1, X2) -> U12#(X1, X2)}
      Weak:
      {                mark U12(X1, X2) -> active U12(mark X1, X2),
                   mark splitAt(X1, X2) -> active splitAt(mark X1, mark X2),
               mark U11(X1, X2, X3, X4) -> active U11(mark X1, X2, X3, X4),
                              mark tt() -> active tt(),
                      mark pair(X1, X2) -> active pair(mark X1, mark X2),
                      mark cons(X1, X2) -> active cons(mark X1, X2),
                             mark snd X -> active snd mark X,
                  mark afterNth(X1, X2) -> active afterNth(mark X1, mark X2),
                       mark and(X1, X2) -> active and(mark X1, X2),
                             mark fst X -> active fst mark X,
                            mark head X -> active head mark X,
                        mark natsFrom X -> active natsFrom mark X,
                               mark s X -> active s mark X,
                       mark sel(X1, X2) -> active sel(mark X1, mark X2),
                             mark nil() -> active nil(),
                               mark 0() -> active 0(),
                            mark tail X -> active tail mark X,
                      mark take(X1, X2) -> active take(mark X1, mark X2),
                       U12(X1, mark X2) -> U12(X1, X2),
                     U12(X1, active X2) -> U12(X1, X2),
                       U12(mark X1, X2) -> U12(X1, X2),
                     U12(active X1, X2) -> U12(X1, X2),
                   splitAt(X1, mark X2) -> splitAt(X1, X2),
                 splitAt(X1, active X2) -> splitAt(X1, X2),
                   splitAt(mark X1, X2) -> splitAt(X1, X2),
                 splitAt(active X1, X2) -> splitAt(X1, X2),
            active U12(pair(YS, ZS), X) -> mark pair(cons(X, YS), ZS),
       active splitAt(s N, cons(X, XS)) -> mark U11(tt(), N, X, XS),
                active splitAt(0(), XS) -> mark pair(nil(), XS),
             active U11(tt(), N, X, XS) -> mark U12(splitAt(N, XS), X),
                  active snd pair(X, Y) -> mark Y,
                 active afterNth(N, XS) -> mark snd splitAt(N, XS),
                    active and(tt(), X) -> mark X,
                  active fst pair(X, Y) -> mark X,
                active head cons(N, XS) -> mark N,
                      active natsFrom N -> mark cons(N, natsFrom s N),
                      active sel(N, XS) -> mark head afterNth(N, XS),
                active tail cons(N, XS) -> mark XS,
                     active take(N, XS) -> mark fst splitAt(N, XS),
               U11(X1, X2, X3, mark X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, X3, active X4) -> U11(X1, X2, X3, X4),
               U11(X1, X2, mark X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, X2, active X3, X4) -> U11(X1, X2, X3, X4),
               U11(X1, mark X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(X1, active X2, X3, X4) -> U11(X1, X2, X3, X4),
               U11(mark X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
             U11(active X1, X2, X3, X4) -> U11(X1, X2, X3, X4),
                      pair(X1, mark X2) -> pair(X1, X2),
                    pair(X1, active X2) -> pair(X1, X2),
                      pair(mark X1, X2) -> pair(X1, X2),
                    pair(active X1, X2) -> pair(X1, X2),
                      cons(X1, mark X2) -> cons(X1, X2),
                    cons(X1, active X2) -> cons(X1, X2),
                      cons(mark X1, X2) -> cons(X1, X2),
                    cons(active X1, X2) -> cons(X1, X2),
                             snd mark X -> snd X,
                           snd active X -> snd X,
                  afterNth(X1, mark X2) -> afterNth(X1, X2),
                afterNth(X1, active X2) -> afterNth(X1, X2),
                  afterNth(mark X1, X2) -> afterNth(X1, X2),
                afterNth(active X1, X2) -> afterNth(X1, X2),
                       and(X1, mark X2) -> and(X1, X2),
                     and(X1, active X2) -> and(X1, X2),
                       and(mark X1, X2) -> and(X1, X2),
                     and(active X1, X2) -> and(X1, X2),
                             fst mark X -> fst X,
                           fst active X -> fst X,
                            head mark X -> head X,
                          head active X -> head X,
                        natsFrom mark X -> natsFrom X,
                      natsFrom active X -> natsFrom X,
                               s mark X -> s X,
                             s active X -> s X,
                       sel(X1, mark X2) -> sel(X1, X2),
                     sel(X1, active X2) -> sel(X1, X2),
                       sel(mark X1, X2) -> sel(X1, X2),
                     sel(active X1, X2) -> sel(X1, X2),
                            tail mark X -> tail X,
                          tail active X -> tail X,
                      take(X1, mark X2) -> take(X1, X2),
                    take(X1, active X2) -> take(X1, X2),
                      take(mark X1, X2) -> take(X1, X2),
                    take(active X1, X2) -> take(X1, X2)}
      Open