YES
Time: 0.806056
TRS:
 {           active and(X1, X2) -> and(active X1, X2),
          active and(true(), X) -> mark X,
         active and(false(), Y) -> mark false(),
          active if(X1, X2, X3) -> if(active X1, X2, X3),
        active if(true(), X, Y) -> mark X,
       active if(false(), X, Y) -> mark Y,
             active add(X1, X2) -> add(active X1, X2),
             active add(0(), X) -> mark X,
             active add(s X, Y) -> mark s add(X, Y),
           active first(X1, X2) -> first(X1, active X2),
           active first(X1, X2) -> first(active X1, X2),
           active first(0(), X) -> mark nil(),
  active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                  active from X -> mark cons(X, from s X),
               and(mark X1, X2) -> mark and(X1, X2),
              and(ok X1, ok X2) -> ok and(X1, X2),
            if(mark X1, X2, X3) -> mark if(X1, X2, X3),
        if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
               add(mark X1, X2) -> mark add(X1, X2),
              add(ok X1, ok X2) -> ok add(X1, X2),
                         s ok X -> ok s X,
             first(X1, mark X2) -> mark first(X1, X2),
             first(mark X1, X2) -> mark first(X1, X2),
            first(ok X1, ok X2) -> ok first(X1, X2),
             cons(ok X1, ok X2) -> ok cons(X1, X2),
                      from ok X -> ok from X,
             proper and(X1, X2) -> and(proper X1, proper X2),
                  proper true() -> ok true(),
                 proper false() -> ok false(),
          proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
             proper add(X1, X2) -> add(proper X1, proper X2),
                     proper 0() -> ok 0(),
                     proper s X -> s proper X,
                   proper nil() -> ok nil(),
           proper first(X1, X2) -> first(proper X1, proper X2),
            proper cons(X1, X2) -> cons(proper X1, proper X2),
                  proper from X -> from proper X,
                     top mark X -> top proper X,
                       top ok X -> top active X}
 DP:
  DP:
   {           active# and(X1, X2) -> active# X1,
               active# and(X1, X2) -> and#(active X1, X2),
            active# if(X1, X2, X3) -> active# X1,
            active# if(X1, X2, X3) -> if#(active X1, X2, X3),
               active# add(X1, X2) -> active# X1,
               active# add(X1, X2) -> add#(active X1, X2),
               active# add(s X, Y) -> add#(X, Y),
               active# add(s X, Y) -> s# add(X, Y),
             active# first(X1, X2) -> active# X1,
             active# first(X1, X2) -> active# X2,
             active# first(X1, X2) -> first#(X1, active X2),
             active# first(X1, X2) -> first#(active X1, X2),
    active# first(s X, cons(Y, Z)) -> first#(X, Z),
    active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)),
                    active# from X -> s# X,
                    active# from X -> cons#(X, from s X),
                    active# from X -> from# s X,
                 and#(mark X1, X2) -> and#(X1, X2),
                and#(ok X1, ok X2) -> and#(X1, X2),
              if#(mark X1, X2, X3) -> if#(X1, X2, X3),
          if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3),
                 add#(mark X1, X2) -> add#(X1, X2),
                add#(ok X1, ok X2) -> add#(X1, X2),
                           s# ok X -> s# X,
               first#(X1, mark X2) -> first#(X1, X2),
               first#(mark X1, X2) -> first#(X1, X2),
              first#(ok X1, ok X2) -> first#(X1, X2),
               cons#(ok X1, ok X2) -> cons#(X1, X2),
                        from# ok X -> from# X,
               proper# and(X1, X2) -> and#(proper X1, proper X2),
               proper# and(X1, X2) -> proper# X1,
               proper# and(X1, X2) -> proper# X2,
            proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3),
            proper# if(X1, X2, X3) -> proper# X1,
            proper# if(X1, X2, X3) -> proper# X2,
            proper# if(X1, X2, X3) -> proper# X3,
               proper# add(X1, X2) -> add#(proper X1, proper X2),
               proper# add(X1, X2) -> proper# X1,
               proper# add(X1, X2) -> proper# X2,
                       proper# s X -> s# proper X,
                       proper# s X -> proper# X,
             proper# first(X1, X2) -> first#(proper X1, proper X2),
             proper# first(X1, X2) -> proper# X1,
             proper# first(X1, X2) -> proper# X2,
              proper# cons(X1, X2) -> cons#(proper X1, proper X2),
              proper# cons(X1, X2) -> proper# X1,
              proper# cons(X1, X2) -> proper# X2,
                    proper# from X -> from# proper X,
                    proper# from X -> proper# X,
                       top# mark X -> proper# X,
                       top# mark X -> top# proper X,
                         top# ok X -> active# X,
                         top# ok X -> top# active X}
  TRS:
  {           active and(X1, X2) -> and(active X1, X2),
           active and(true(), X) -> mark X,
          active and(false(), Y) -> mark false(),
           active if(X1, X2, X3) -> if(active X1, X2, X3),
         active if(true(), X, Y) -> mark X,
        active if(false(), X, Y) -> mark Y,
              active add(X1, X2) -> add(active X1, X2),
              active add(0(), X) -> mark X,
              active add(s X, Y) -> mark s add(X, Y),
            active first(X1, X2) -> first(X1, active X2),
            active first(X1, X2) -> first(active X1, X2),
            active first(0(), X) -> mark nil(),
   active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                   active from X -> mark cons(X, from s X),
                and(mark X1, X2) -> mark and(X1, X2),
               and(ok X1, ok X2) -> ok and(X1, X2),
             if(mark X1, X2, X3) -> mark if(X1, X2, X3),
         if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                add(mark X1, X2) -> mark add(X1, X2),
               add(ok X1, ok X2) -> ok add(X1, X2),
                          s ok X -> ok s X,
              first(X1, mark X2) -> mark first(X1, X2),
              first(mark X1, X2) -> mark first(X1, X2),
             first(ok X1, ok X2) -> ok first(X1, X2),
              cons(ok X1, ok X2) -> ok cons(X1, X2),
                       from ok X -> ok from X,
              proper and(X1, X2) -> and(proper X1, proper X2),
                   proper true() -> ok true(),
                  proper false() -> ok false(),
           proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
              proper add(X1, X2) -> add(proper X1, proper X2),
                      proper 0() -> ok 0(),
                      proper s X -> s proper X,
                    proper nil() -> ok nil(),
            proper first(X1, X2) -> first(proper X1, proper X2),
             proper cons(X1, X2) -> cons(proper X1, proper X2),
                   proper from X -> from proper X,
                      top mark X -> top proper X,
                        top ok X -> top active X}
  UR:
   {           active and(X1, X2) -> and(active X1, X2),
            active and(true(), X) -> mark X,
           active and(false(), Y) -> mark false(),
            active if(X1, X2, X3) -> if(active X1, X2, X3),
          active if(true(), X, Y) -> mark X,
         active if(false(), X, Y) -> mark Y,
               active add(X1, X2) -> add(active X1, X2),
               active add(0(), X) -> mark X,
               active add(s X, Y) -> mark s add(X, Y),
             active first(X1, X2) -> first(X1, active X2),
             active first(X1, X2) -> first(active X1, X2),
             active first(0(), X) -> mark nil(),
    active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                    active from X -> mark cons(X, from s X),
                 and(mark X1, X2) -> mark and(X1, X2),
                and(ok X1, ok X2) -> ok and(X1, X2),
              if(mark X1, X2, X3) -> mark if(X1, X2, X3),
          if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                 add(mark X1, X2) -> mark add(X1, X2),
                add(ok X1, ok X2) -> ok add(X1, X2),
                           s ok X -> ok s X,
               first(X1, mark X2) -> mark first(X1, X2),
               first(mark X1, X2) -> mark first(X1, X2),
              first(ok X1, ok X2) -> ok first(X1, X2),
               cons(ok X1, ok X2) -> ok cons(X1, X2),
                        from ok X -> ok from X,
               proper and(X1, X2) -> and(proper X1, proper X2),
                    proper true() -> ok true(),
                   proper false() -> ok false(),
            proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
               proper add(X1, X2) -> add(proper X1, proper X2),
                       proper 0() -> ok 0(),
                       proper s X -> s proper X,
                     proper nil() -> ok nil(),
             proper first(X1, X2) -> first(proper X1, proper X2),
              proper cons(X1, X2) -> cons(proper X1, proper X2),
                    proper from X -> from proper X,
                          a(x, y) -> x,
                          a(x, y) -> y}
   EDG:
    {
     (active# from X -> s# X, s# ok X -> s# X)
     (from# ok X -> from# X, from# ok X -> from# X)
     (proper# from X -> proper# X, proper# from X -> proper# X)
     (proper# from X -> proper# X, proper# from X -> from# proper X)
     (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# s X -> proper# X)
     (proper# from X -> proper# X, proper# s X -> s# proper X)
     (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
     (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
     (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
     (proper# from X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (top# ok X -> active# X, active# from X -> from# s X)
     (top# ok X -> active# X, active# from X -> cons#(X, from s X))
     (top# ok X -> active# X, active# from X -> s# X)
     (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
     (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> first#(X, Z))
     (top# ok X -> active# X, active# first(X1, X2) -> first#(active X1, X2))
     (top# ok X -> active# X, active# first(X1, X2) -> first#(X1, active X2))
     (top# ok X -> active# X, active# first(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# first(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# add(s X, Y) -> s# add(X, Y))
     (top# ok X -> active# X, active# add(s X, Y) -> add#(X, Y))
     (top# ok X -> active# X, active# add(X1, X2) -> add#(active X1, X2))
     (top# ok X -> active# X, active# add(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
     (top# ok X -> active# X, active# if(X1, X2, X3) -> active# X1)
     (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
     (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
     (active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (active# and(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# and(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# and(X1, X2) -> active# X1, active# from X -> s# X)
     (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
     (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
     (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
     (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
     (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
     (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
     (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
     (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
     (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# add(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# add(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# add(X1, X2) -> active# X1, active# from X -> s# X)
     (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
     (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
     (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
     (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
     (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
     (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
     (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
     (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
     (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
     (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
     (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
     (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
     (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (proper# and(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
     (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# add(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# add(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
     (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
     (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
     (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
     (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (active# first(X1, X2) -> first#(X1, active X2), first#(ok X1, ok X2) -> first#(X1, X2))
     (active# first(X1, X2) -> first#(X1, active X2), first#(mark X1, X2) -> first#(X1, X2))
     (active# first(X1, X2) -> first#(X1, active X2), first#(X1, mark X2) -> first#(X1, X2))
     (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(ok X1, ok X2) -> add#(X1, X2))
     (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(mark X1, X2) -> add#(X1, X2))
     (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (proper# and(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
     (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# add(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# add(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
     (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
     (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
     (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
     (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(ok X1, ok X2) -> first#(X1, X2))
     (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(mark X1, X2) -> first#(X1, X2))
     (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(X1, mark X2) -> first#(X1, X2))
     (active# add(X1, X2) -> add#(active X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
     (active# add(X1, X2) -> add#(active X1, X2), add#(mark X1, X2) -> add#(X1, X2))
     (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
     (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
     (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
     (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
     (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
     (add#(ok X1, ok X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
     (add#(ok X1, ok X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
     (first#(mark X1, X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
     (first#(mark X1, X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
     (first#(mark X1, X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
     (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (proper# s X -> s# proper X, s# ok X -> s# X)
     (top# mark X -> top# proper X, top# ok X -> top# active X)
     (top# mark X -> top# proper X, top# ok X -> active# X)
     (top# mark X -> top# proper X, top# mark X -> top# proper X)
     (top# mark X -> top# proper X, top# mark X -> proper# X)
     (top# ok X -> top# active X, top# mark X -> proper# X)
     (top# ok X -> top# active X, top# mark X -> top# proper X)
     (top# ok X -> top# active X, top# ok X -> active# X)
     (top# ok X -> top# active X, top# ok X -> top# active X)
     (proper# from X -> from# proper X, from# ok X -> from# X)
     (active# from X -> from# s X, from# ok X -> from# X)
     (first#(ok X1, ok X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
     (first#(ok X1, ok X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
     (first#(ok X1, ok X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
     (first#(X1, mark X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
     (first#(X1, mark X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
     (first#(X1, mark X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
     (add#(mark X1, X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
     (add#(mark X1, X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
     (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
     (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
     (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
     (active# first(X1, X2) -> first#(active X1, X2), first#(X1, mark X2) -> first#(X1, X2))
     (active# first(X1, X2) -> first#(active X1, X2), first#(mark X1, X2) -> first#(X1, X2))
     (active# first(X1, X2) -> first#(active X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
     (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
     (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X3)
     (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> s# proper X)
     (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> proper# X)
     (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> from# proper X)
     (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> proper# X)
     (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
     (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
     (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
     (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# first(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# first(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
     (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> s# proper X)
     (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> proper# X)
     (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> from# proper X)
     (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> proper# X)
     (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
     (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
     (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> active# X1)
     (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
     (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> active# X1)
     (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> add#(active X1, X2))
     (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> add#(X, Y))
     (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> s# add(X, Y))
     (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X1)
     (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X2)
     (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(X1, active X2))
     (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(active X1, X2))
     (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> first#(X, Z))
     (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
     (active# first(X1, X2) -> active# X2, active# from X -> s# X)
     (active# first(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
     (active# first(X1, X2) -> active# X2, active# from X -> from# s X)
     (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(X1, mark X2) -> first#(X1, X2))
     (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(mark X1, X2) -> first#(X1, X2))
     (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(ok X1, ok X2) -> first#(X1, X2))
     (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
     (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
     (active# add(s X, Y) -> s# add(X, Y), s# ok X -> s# X)
     (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
     (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
     (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
     (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# first(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# first(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# first(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
     (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> s# proper X)
     (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> proper# X)
     (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> from# proper X)
     (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> proper# X)
     (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
     (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
     (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
     (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
     (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
     (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
     (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
     (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
     (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
     (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
     (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
     (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
     (active# first(X1, X2) -> active# X1, active# from X -> s# X)
     (active# first(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# first(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> active# X1)
     (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
     (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> active# X1)
     (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
     (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> active# X1)
     (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
     (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> add#(X, Y))
     (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
     (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X1)
     (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X2)
     (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
     (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
     (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
     (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
     (active# if(X1, X2, X3) -> active# X1, active# from X -> s# X)
     (active# if(X1, X2, X3) -> active# X1, active# from X -> cons#(X, from s X))
     (active# if(X1, X2, X3) -> active# X1, active# from X -> from# s X)
     (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
     (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
     (active# from X -> cons#(X, from s X), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
     (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
     (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
     (top# mark X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# s X -> s# proper X)
     (top# mark X -> proper# X, proper# s X -> proper# X)
     (top# mark X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# from X -> from# proper X)
     (top# mark X -> proper# X, proper# from X -> proper# X)
     (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
     (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
     (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
     (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
     (proper# s X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# s X -> s# proper X)
     (proper# s X -> proper# X, proper# s X -> proper# X)
     (proper# s X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# from X -> from# proper X)
     (proper# s X -> proper# X, proper# from X -> proper# X)
     (s# ok X -> s# X, s# ok X -> s# X)
     (active# add(s X, Y) -> add#(X, Y), add#(mark X1, X2) -> add#(X1, X2))
     (active# add(s X, Y) -> add#(X, Y), add#(ok X1, ok X2) -> add#(X1, X2))
    }
    EDG:
     {
      (active# from X -> s# X, s# ok X -> s# X)
      (from# ok X -> from# X, from# ok X -> from# X)
      (proper# from X -> proper# X, proper# from X -> proper# X)
      (proper# from X -> proper# X, proper# from X -> from# proper X)
      (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# from X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X2)
      (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X1)
      (proper# from X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# from X -> proper# X, proper# s X -> proper# X)
      (proper# from X -> proper# X, proper# s X -> s# proper X)
      (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X2)
      (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X1)
      (proper# from X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
      (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
      (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
      (proper# from X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# from X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (top# ok X -> active# X, active# from X -> from# s X)
      (top# ok X -> active# X, active# from X -> cons#(X, from s X))
      (top# ok X -> active# X, active# from X -> s# X)
      (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
      (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> first#(X, Z))
      (top# ok X -> active# X, active# first(X1, X2) -> first#(active X1, X2))
      (top# ok X -> active# X, active# first(X1, X2) -> first#(X1, active X2))
      (top# ok X -> active# X, active# first(X1, X2) -> active# X2)
      (top# ok X -> active# X, active# first(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# add(s X, Y) -> s# add(X, Y))
      (top# ok X -> active# X, active# add(s X, Y) -> add#(X, Y))
      (top# ok X -> active# X, active# add(X1, X2) -> add#(active X1, X2))
      (top# ok X -> active# X, active# add(X1, X2) -> active# X1)
      (top# ok X -> active# X, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
      (top# ok X -> active# X, active# if(X1, X2, X3) -> active# X1)
      (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
      (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
      (active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (active# and(X1, X2) -> active# X1, active# from X -> from# s X)
      (active# and(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
      (active# and(X1, X2) -> active# X1, active# from X -> s# X)
      (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
      (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
      (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
      (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
      (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
      (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
      (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
      (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
      (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# add(X1, X2) -> active# X1, active# from X -> from# s X)
      (active# add(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
      (active# add(X1, X2) -> active# X1, active# from X -> s# X)
      (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
      (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
      (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
      (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
      (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
      (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
      (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
      (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
      (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
      (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
      (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
      (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
      (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (proper# and(X1, X2) -> proper# X1, proper# from X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# from X -> from# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
      (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X1, proper# from X -> proper# X)
      (proper# add(X1, X2) -> proper# X1, proper# from X -> from# proper X)
      (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# add(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
      (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
      (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
      (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# from X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# from X -> from# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
      (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (active# first(X1, X2) -> first#(X1, active X2), first#(ok X1, ok X2) -> first#(X1, X2))
      (active# first(X1, X2) -> first#(X1, active X2), first#(mark X1, X2) -> first#(X1, X2))
      (active# first(X1, X2) -> first#(X1, active X2), first#(X1, mark X2) -> first#(X1, X2))
      (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(ok X1, ok X2) -> add#(X1, X2))
      (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(mark X1, X2) -> add#(X1, X2))
      (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (proper# and(X1, X2) -> proper# X2, proper# from X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# from X -> from# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
      (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X2, proper# from X -> proper# X)
      (proper# add(X1, X2) -> proper# X2, proper# from X -> from# proper X)
      (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# add(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
      (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
      (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
      (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# from X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# from X -> from# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
      (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(ok X1, ok X2) -> first#(X1, X2))
      (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(mark X1, X2) -> first#(X1, X2))
      (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(X1, mark X2) -> first#(X1, X2))
      (active# add(X1, X2) -> add#(active X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
      (active# add(X1, X2) -> add#(active X1, X2), add#(mark X1, X2) -> add#(X1, X2))
      (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
      (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
      (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
      (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
      (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
      (add#(ok X1, ok X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
      (add#(ok X1, ok X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
      (first#(mark X1, X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
      (first#(mark X1, X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
      (first#(mark X1, X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
      (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (proper# s X -> s# proper X, s# ok X -> s# X)
      (top# mark X -> top# proper X, top# ok X -> top# active X)
      (top# mark X -> top# proper X, top# ok X -> active# X)
      (top# mark X -> top# proper X, top# mark X -> top# proper X)
      (top# mark X -> top# proper X, top# mark X -> proper# X)
      (top# ok X -> top# active X, top# mark X -> proper# X)
      (top# ok X -> top# active X, top# mark X -> top# proper X)
      (top# ok X -> top# active X, top# ok X -> active# X)
      (top# ok X -> top# active X, top# ok X -> top# active X)
      (proper# from X -> from# proper X, from# ok X -> from# X)
      (active# from X -> from# s X, from# ok X -> from# X)
      (first#(ok X1, ok X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
      (first#(ok X1, ok X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
      (first#(ok X1, ok X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
      (first#(X1, mark X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
      (first#(X1, mark X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
      (first#(X1, mark X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
      (add#(mark X1, X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
      (add#(mark X1, X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
      (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
      (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
      (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
      (active# first(X1, X2) -> first#(active X1, X2), first#(X1, mark X2) -> first#(X1, X2))
      (active# first(X1, X2) -> first#(active X1, X2), first#(mark X1, X2) -> first#(X1, X2))
      (active# first(X1, X2) -> first#(active X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
      (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
      (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X3)
      (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> s# proper X)
      (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> proper# X)
      (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> from# proper X)
      (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> proper# X)
      (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
      (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
      (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
      (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X2, proper# s X -> s# proper X)
      (proper# first(X1, X2) -> proper# X2, proper# s X -> proper# X)
      (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X2, proper# from X -> from# proper X)
      (proper# first(X1, X2) -> proper# X2, proper# from X -> proper# X)
      (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
      (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> s# proper X)
      (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> proper# X)
      (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> from# proper X)
      (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> proper# X)
      (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
      (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
      (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> active# X1)
      (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
      (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> active# X1)
      (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> add#(active X1, X2))
      (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> add#(X, Y))
      (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> s# add(X, Y))
      (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X1)
      (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X2)
      (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(X1, active X2))
      (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(active X1, X2))
      (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> first#(X, Z))
      (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
      (active# first(X1, X2) -> active# X2, active# from X -> s# X)
      (active# first(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
      (active# first(X1, X2) -> active# X2, active# from X -> from# s X)
      (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(X1, mark X2) -> first#(X1, X2))
      (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(mark X1, X2) -> first#(X1, X2))
      (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(ok X1, ok X2) -> first#(X1, X2))
      (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
      (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
      (active# add(s X, Y) -> s# add(X, Y), s# ok X -> s# X)
      (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
      (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
      (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
      (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X1, proper# s X -> s# proper X)
      (proper# first(X1, X2) -> proper# X1, proper# s X -> proper# X)
      (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# first(X1, X2) -> proper# X1, proper# from X -> from# proper X)
      (proper# first(X1, X2) -> proper# X1, proper# from X -> proper# X)
      (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
      (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> s# proper X)
      (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> proper# X)
      (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
      (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
      (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> from# proper X)
      (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> proper# X)
      (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
      (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
      (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
      (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
      (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
      (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
      (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
      (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
      (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
      (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
      (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
      (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
      (active# first(X1, X2) -> active# X1, active# from X -> s# X)
      (active# first(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
      (active# first(X1, X2) -> active# X1, active# from X -> from# s X)
      (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> active# X1)
      (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
      (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> active# X1)
      (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
      (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> active# X1)
      (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
      (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> add#(X, Y))
      (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
      (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X1)
      (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X2)
      (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
      (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
      (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
      (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
      (active# if(X1, X2, X3) -> active# X1, active# from X -> s# X)
      (active# if(X1, X2, X3) -> active# X1, active# from X -> cons#(X, from s X))
      (active# if(X1, X2, X3) -> active# X1, active# from X -> from# s X)
      (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
      (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
      (active# from X -> cons#(X, from s X), cons#(ok X1, ok X2) -> cons#(X1, X2))
      (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
      (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
      (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
      (top# mark X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# s X -> s# proper X)
      (top# mark X -> proper# X, proper# s X -> proper# X)
      (top# mark X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (top# mark X -> proper# X, proper# from X -> from# proper X)
      (top# mark X -> proper# X, proper# from X -> proper# X)
      (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
      (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
      (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
      (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
      (proper# s X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# s X -> s# proper X)
      (proper# s X -> proper# X, proper# s X -> proper# X)
      (proper# s X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
      (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
      (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
      (proper# s X -> proper# X, proper# from X -> from# proper X)
      (proper# s X -> proper# X, proper# from X -> proper# X)
      (s# ok X -> s# X, s# ok X -> s# X)
      (active# add(s X, Y) -> add#(X, Y), add#(mark X1, X2) -> add#(X1, X2))
      (active# add(s X, Y) -> add#(X, Y), add#(ok X1, ok X2) -> add#(X1, X2))
     }
     EDG:
      {
       (active# from X -> s# X, s# ok X -> s# X)
       (from# ok X -> from# X, from# ok X -> from# X)
       (proper# from X -> proper# X, proper# from X -> proper# X)
       (proper# from X -> proper# X, proper# from X -> from# proper X)
       (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# from X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X2)
       (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X1)
       (proper# from X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# from X -> proper# X, proper# s X -> proper# X)
       (proper# from X -> proper# X, proper# s X -> s# proper X)
       (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X2)
       (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X1)
       (proper# from X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
       (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
       (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
       (proper# from X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# from X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (top# ok X -> active# X, active# from X -> from# s X)
       (top# ok X -> active# X, active# from X -> cons#(X, from s X))
       (top# ok X -> active# X, active# from X -> s# X)
       (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
       (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> first#(X, Z))
       (top# ok X -> active# X, active# first(X1, X2) -> first#(active X1, X2))
       (top# ok X -> active# X, active# first(X1, X2) -> first#(X1, active X2))
       (top# ok X -> active# X, active# first(X1, X2) -> active# X2)
       (top# ok X -> active# X, active# first(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# add(s X, Y) -> s# add(X, Y))
       (top# ok X -> active# X, active# add(s X, Y) -> add#(X, Y))
       (top# ok X -> active# X, active# add(X1, X2) -> add#(active X1, X2))
       (top# ok X -> active# X, active# add(X1, X2) -> active# X1)
       (top# ok X -> active# X, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
       (top# ok X -> active# X, active# if(X1, X2, X3) -> active# X1)
       (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
       (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
       (active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (active# and(X1, X2) -> active# X1, active# from X -> from# s X)
       (active# and(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
       (active# and(X1, X2) -> active# X1, active# from X -> s# X)
       (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
       (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
       (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
       (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
       (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
       (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
       (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
       (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
       (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# add(X1, X2) -> active# X1, active# from X -> from# s X)
       (active# add(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
       (active# add(X1, X2) -> active# X1, active# from X -> s# X)
       (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
       (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
       (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
       (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
       (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
       (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
       (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
       (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
       (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
       (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
       (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
       (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
       (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (proper# and(X1, X2) -> proper# X1, proper# from X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# from X -> from# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
       (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X1, proper# from X -> proper# X)
       (proper# add(X1, X2) -> proper# X1, proper# from X -> from# proper X)
       (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# add(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
       (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
       (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
       (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# from X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# from X -> from# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
       (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (active# first(X1, X2) -> first#(X1, active X2), first#(ok X1, ok X2) -> first#(X1, X2))
       (active# first(X1, X2) -> first#(X1, active X2), first#(mark X1, X2) -> first#(X1, X2))
       (active# first(X1, X2) -> first#(X1, active X2), first#(X1, mark X2) -> first#(X1, X2))
       (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(ok X1, ok X2) -> add#(X1, X2))
       (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(mark X1, X2) -> add#(X1, X2))
       (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (proper# and(X1, X2) -> proper# X2, proper# from X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# from X -> from# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
       (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X2, proper# from X -> proper# X)
       (proper# add(X1, X2) -> proper# X2, proper# from X -> from# proper X)
       (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# add(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
       (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
       (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
       (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# from X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# from X -> from# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
       (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(ok X1, ok X2) -> first#(X1, X2))
       (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(mark X1, X2) -> first#(X1, X2))
       (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(X1, mark X2) -> first#(X1, X2))
       (active# add(X1, X2) -> add#(active X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
       (active# add(X1, X2) -> add#(active X1, X2), add#(mark X1, X2) -> add#(X1, X2))
       (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
       (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
       (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
       (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
       (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
       (add#(ok X1, ok X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
       (add#(ok X1, ok X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
       (first#(mark X1, X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
       (first#(mark X1, X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
       (first#(mark X1, X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
       (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (proper# s X -> s# proper X, s# ok X -> s# X)
       (top# mark X -> top# proper X, top# ok X -> top# active X)
       (top# mark X -> top# proper X, top# ok X -> active# X)
       (top# mark X -> top# proper X, top# mark X -> top# proper X)
       (top# mark X -> top# proper X, top# mark X -> proper# X)
       (top# ok X -> top# active X, top# mark X -> proper# X)
       (top# ok X -> top# active X, top# mark X -> top# proper X)
       (top# ok X -> top# active X, top# ok X -> active# X)
       (top# ok X -> top# active X, top# ok X -> top# active X)
       (proper# from X -> from# proper X, from# ok X -> from# X)
       (active# from X -> from# s X, from# ok X -> from# X)
       (first#(ok X1, ok X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
       (first#(ok X1, ok X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
       (first#(ok X1, ok X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
       (first#(X1, mark X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
       (first#(X1, mark X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
       (first#(X1, mark X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
       (add#(mark X1, X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
       (add#(mark X1, X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
       (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
       (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
       (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
       (active# first(X1, X2) -> first#(active X1, X2), first#(X1, mark X2) -> first#(X1, X2))
       (active# first(X1, X2) -> first#(active X1, X2), first#(mark X1, X2) -> first#(X1, X2))
       (active# first(X1, X2) -> first#(active X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
       (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
       (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X3)
       (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> s# proper X)
       (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> proper# X)
       (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> from# proper X)
       (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> proper# X)
       (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
       (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
       (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
       (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X2, proper# s X -> s# proper X)
       (proper# first(X1, X2) -> proper# X2, proper# s X -> proper# X)
       (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X2, proper# from X -> from# proper X)
       (proper# first(X1, X2) -> proper# X2, proper# from X -> proper# X)
       (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
       (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> s# proper X)
       (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> proper# X)
       (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> from# proper X)
       (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> proper# X)
       (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
       (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
       (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> active# X1)
       (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
       (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> active# X1)
       (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> add#(active X1, X2))
       (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> add#(X, Y))
       (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> s# add(X, Y))
       (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X1)
       (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X2)
       (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(X1, active X2))
       (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(active X1, X2))
       (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> first#(X, Z))
       (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
       (active# first(X1, X2) -> active# X2, active# from X -> s# X)
       (active# first(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
       (active# first(X1, X2) -> active# X2, active# from X -> from# s X)
       (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(X1, mark X2) -> first#(X1, X2))
       (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(mark X1, X2) -> first#(X1, X2))
       (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(ok X1, ok X2) -> first#(X1, X2))
       (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
       (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
       (active# add(s X, Y) -> s# add(X, Y), s# ok X -> s# X)
       (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
       (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
       (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
       (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X1, proper# s X -> s# proper X)
       (proper# first(X1, X2) -> proper# X1, proper# s X -> proper# X)
       (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# first(X1, X2) -> proper# X1, proper# from X -> from# proper X)
       (proper# first(X1, X2) -> proper# X1, proper# from X -> proper# X)
       (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
       (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> s# proper X)
       (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> proper# X)
       (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
       (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
       (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> from# proper X)
       (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> proper# X)
       (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
       (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
       (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
       (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
       (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
       (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
       (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
       (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
       (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
       (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
       (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
       (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
       (active# first(X1, X2) -> active# X1, active# from X -> s# X)
       (active# first(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
       (active# first(X1, X2) -> active# X1, active# from X -> from# s X)
       (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> active# X1)
       (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
       (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> active# X1)
       (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
       (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> active# X1)
       (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
       (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> add#(X, Y))
       (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
       (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X1)
       (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X2)
       (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
       (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
       (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
       (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
       (active# if(X1, X2, X3) -> active# X1, active# from X -> s# X)
       (active# if(X1, X2, X3) -> active# X1, active# from X -> cons#(X, from s X))
       (active# if(X1, X2, X3) -> active# X1, active# from X -> from# s X)
       (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
       (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
       (active# from X -> cons#(X, from s X), cons#(ok X1, ok X2) -> cons#(X1, X2))
       (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
       (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
       (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
       (top# mark X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# s X -> s# proper X)
       (top# mark X -> proper# X, proper# s X -> proper# X)
       (top# mark X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (top# mark X -> proper# X, proper# from X -> from# proper X)
       (top# mark X -> proper# X, proper# from X -> proper# X)
       (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
       (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
       (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
       (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
       (proper# s X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# s X -> s# proper X)
       (proper# s X -> proper# X, proper# s X -> proper# X)
       (proper# s X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
       (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
       (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
       (proper# s X -> proper# X, proper# from X -> from# proper X)
       (proper# s X -> proper# X, proper# from X -> proper# X)
       (s# ok X -> s# X, s# ok X -> s# X)
       (active# add(s X, Y) -> add#(X, Y), add#(mark X1, X2) -> add#(X1, X2))
       (active# add(s X, Y) -> add#(X, Y), add#(ok X1, ok X2) -> add#(X1, X2))
      }
      EDG:
       {
        (active# from X -> s# X, s# ok X -> s# X)
        (from# ok X -> from# X, from# ok X -> from# X)
        (proper# from X -> proper# X, proper# from X -> proper# X)
        (proper# from X -> proper# X, proper# from X -> from# proper X)
        (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# from X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X2)
        (proper# from X -> proper# X, proper# first(X1, X2) -> proper# X1)
        (proper# from X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# from X -> proper# X, proper# s X -> proper# X)
        (proper# from X -> proper# X, proper# s X -> s# proper X)
        (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X2)
        (proper# from X -> proper# X, proper# add(X1, X2) -> proper# X1)
        (proper# from X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
        (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
        (proper# from X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
        (proper# from X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# from X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# from X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (top# ok X -> active# X, active# from X -> from# s X)
        (top# ok X -> active# X, active# from X -> cons#(X, from s X))
        (top# ok X -> active# X, active# from X -> s# X)
        (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
        (top# ok X -> active# X, active# first(s X, cons(Y, Z)) -> first#(X, Z))
        (top# ok X -> active# X, active# first(X1, X2) -> first#(active X1, X2))
        (top# ok X -> active# X, active# first(X1, X2) -> first#(X1, active X2))
        (top# ok X -> active# X, active# first(X1, X2) -> active# X2)
        (top# ok X -> active# X, active# first(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# add(s X, Y) -> s# add(X, Y))
        (top# ok X -> active# X, active# add(s X, Y) -> add#(X, Y))
        (top# ok X -> active# X, active# add(X1, X2) -> add#(active X1, X2))
        (top# ok X -> active# X, active# add(X1, X2) -> active# X1)
        (top# ok X -> active# X, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
        (top# ok X -> active# X, active# if(X1, X2, X3) -> active# X1)
        (top# ok X -> active# X, active# and(X1, X2) -> and#(active X1, X2))
        (top# ok X -> active# X, active# and(X1, X2) -> active# X1)
        (active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (active# and(X1, X2) -> active# X1, active# from X -> from# s X)
        (active# and(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
        (active# and(X1, X2) -> active# X1, active# from X -> s# X)
        (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
        (active# and(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
        (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
        (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
        (active# and(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
        (active# and(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
        (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
        (active# and(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
        (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# and(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# add(X1, X2) -> active# X1, active# from X -> from# s X)
        (active# add(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
        (active# add(X1, X2) -> active# X1, active# from X -> s# X)
        (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
        (active# add(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
        (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
        (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
        (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
        (active# add(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
        (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
        (active# add(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
        (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
        (active# add(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
        (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
        (active# add(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
        (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# add(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (proper# and(X1, X2) -> proper# X1, proper# from X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# from X -> from# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# and(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
        (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X1, proper# from X -> proper# X)
        (proper# add(X1, X2) -> proper# X1, proper# from X -> from# proper X)
        (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# add(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
        (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
        (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
        (proper# add(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# from X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# from X -> from# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# cons(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
        (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (active# first(X1, X2) -> first#(X1, active X2), first#(ok X1, ok X2) -> first#(X1, X2))
        (active# first(X1, X2) -> first#(X1, active X2), first#(mark X1, X2) -> first#(X1, X2))
        (active# first(X1, X2) -> first#(X1, active X2), first#(X1, mark X2) -> first#(X1, X2))
        (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(ok X1, ok X2) -> add#(X1, X2))
        (proper# add(X1, X2) -> add#(proper X1, proper X2), add#(mark X1, X2) -> add#(X1, X2))
        (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (proper# and(X1, X2) -> proper# X2, proper# from X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# from X -> from# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# and(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
        (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# and(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X2, proper# from X -> proper# X)
        (proper# add(X1, X2) -> proper# X2, proper# from X -> from# proper X)
        (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# add(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
        (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
        (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
        (proper# add(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# add(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# from X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# from X -> from# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
        (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# cons(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(ok X1, ok X2) -> first#(X1, X2))
        (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(mark X1, X2) -> first#(X1, X2))
        (active# first(s X, cons(Y, Z)) -> first#(X, Z), first#(X1, mark X2) -> first#(X1, X2))
        (active# add(X1, X2) -> add#(active X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
        (active# add(X1, X2) -> add#(active X1, X2), add#(mark X1, X2) -> add#(X1, X2))
        (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
        (active# if(X1, X2, X3) -> if#(active X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
        (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
        (if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
        (and#(ok X1, ok X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (and#(ok X1, ok X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
        (add#(ok X1, ok X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
        (add#(ok X1, ok X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
        (first#(mark X1, X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
        (first#(mark X1, X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
        (first#(mark X1, X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
        (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (proper# s X -> s# proper X, s# ok X -> s# X)
        (top# mark X -> top# proper X, top# ok X -> top# active X)
        (top# mark X -> top# proper X, top# ok X -> active# X)
        (top# mark X -> top# proper X, top# mark X -> top# proper X)
        (top# mark X -> top# proper X, top# mark X -> proper# X)
        (top# ok X -> top# active X, top# mark X -> proper# X)
        (top# ok X -> top# active X, top# mark X -> top# proper X)
        (top# ok X -> top# active X, top# ok X -> active# X)
        (top# ok X -> top# active X, top# ok X -> top# active X)
        (proper# from X -> from# proper X, from# ok X -> from# X)
        (active# from X -> from# s X, from# ok X -> from# X)
        (first#(ok X1, ok X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
        (first#(ok X1, ok X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
        (first#(ok X1, ok X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
        (first#(X1, mark X2) -> first#(X1, X2), first#(X1, mark X2) -> first#(X1, X2))
        (first#(X1, mark X2) -> first#(X1, X2), first#(mark X1, X2) -> first#(X1, X2))
        (first#(X1, mark X2) -> first#(X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
        (add#(mark X1, X2) -> add#(X1, X2), add#(mark X1, X2) -> add#(X1, X2))
        (add#(mark X1, X2) -> add#(X1, X2), add#(ok X1, ok X2) -> add#(X1, X2))
        (and#(mark X1, X2) -> and#(X1, X2), and#(mark X1, X2) -> and#(X1, X2))
        (and#(mark X1, X2) -> and#(X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
        (if#(mark X1, X2, X3) -> if#(X1, X2, X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
        (active# first(X1, X2) -> first#(active X1, X2), first#(X1, mark X2) -> first#(X1, X2))
        (active# first(X1, X2) -> first#(active X1, X2), first#(mark X1, X2) -> first#(X1, X2))
        (active# first(X1, X2) -> first#(active X1, X2), first#(ok X1, ok X2) -> first#(X1, X2))
        (active# and(X1, X2) -> and#(active X1, X2), and#(mark X1, X2) -> and#(X1, X2))
        (active# and(X1, X2) -> and#(active X1, X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X3, proper# and(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X3, proper# if(X1, X2, X3) -> proper# X3)
        (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X3, proper# add(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> s# proper X)
        (proper# if(X1, X2, X3) -> proper# X3, proper# s X -> proper# X)
        (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X3, proper# first(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X3, proper# cons(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> from# proper X)
        (proper# if(X1, X2, X3) -> proper# X3, proper# from X -> proper# X)
        (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
        (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
        (proper# first(X1, X2) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
        (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X2, proper# add(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X2, proper# s X -> s# proper X)
        (proper# first(X1, X2) -> proper# X2, proper# s X -> proper# X)
        (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X2, proper# first(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X2, proper# from X -> from# proper X)
        (proper# first(X1, X2) -> proper# X2, proper# from X -> proper# X)
        (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X2, proper# and(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X2, proper# if(X1, X2, X3) -> proper# X3)
        (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X2, proper# add(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> s# proper X)
        (proper# if(X1, X2, X3) -> proper# X2, proper# s X -> proper# X)
        (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X2, proper# first(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> from# proper X)
        (proper# if(X1, X2, X3) -> proper# X2, proper# from X -> proper# X)
        (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> active# X1)
        (active# first(X1, X2) -> active# X2, active# and(X1, X2) -> and#(active X1, X2))
        (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> active# X1)
        (active# first(X1, X2) -> active# X2, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
        (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> active# X1)
        (active# first(X1, X2) -> active# X2, active# add(X1, X2) -> add#(active X1, X2))
        (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> add#(X, Y))
        (active# first(X1, X2) -> active# X2, active# add(s X, Y) -> s# add(X, Y))
        (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X1)
        (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> active# X2)
        (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(X1, active X2))
        (active# first(X1, X2) -> active# X2, active# first(X1, X2) -> first#(active X1, X2))
        (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> first#(X, Z))
        (active# first(X1, X2) -> active# X2, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
        (active# first(X1, X2) -> active# X2, active# from X -> s# X)
        (active# first(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
        (active# first(X1, X2) -> active# X2, active# from X -> from# s X)
        (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(X1, mark X2) -> first#(X1, X2))
        (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(mark X1, X2) -> first#(X1, X2))
        (proper# first(X1, X2) -> first#(proper X1, proper X2), first#(ok X1, ok X2) -> first#(X1, X2))
        (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(mark X1, X2) -> and#(X1, X2))
        (proper# and(X1, X2) -> and#(proper X1, proper X2), and#(ok X1, ok X2) -> and#(X1, X2))
        (active# add(s X, Y) -> s# add(X, Y), s# ok X -> s# X)
        (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
        (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
        (proper# first(X1, X2) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
        (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X1, proper# add(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X1, proper# s X -> s# proper X)
        (proper# first(X1, X2) -> proper# X1, proper# s X -> proper# X)
        (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X1, proper# first(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# first(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# first(X1, X2) -> proper# X1, proper# from X -> from# proper X)
        (proper# first(X1, X2) -> proper# X1, proper# from X -> proper# X)
        (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X1, proper# and(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X1, proper# if(X1, X2, X3) -> proper# X3)
        (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X1, proper# add(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> s# proper X)
        (proper# if(X1, X2, X3) -> proper# X1, proper# s X -> proper# X)
        (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X1, proper# first(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
        (proper# if(X1, X2, X3) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
        (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> from# proper X)
        (proper# if(X1, X2, X3) -> proper# X1, proper# from X -> proper# X)
        (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# first(X1, X2) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> active# X1)
        (active# first(X1, X2) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
        (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> active# X1)
        (active# first(X1, X2) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
        (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> add#(X, Y))
        (active# first(X1, X2) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
        (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X1)
        (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> active# X2)
        (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
        (active# first(X1, X2) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
        (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
        (active# first(X1, X2) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
        (active# first(X1, X2) -> active# X1, active# from X -> s# X)
        (active# first(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
        (active# first(X1, X2) -> active# X1, active# from X -> from# s X)
        (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> active# X1)
        (active# if(X1, X2, X3) -> active# X1, active# and(X1, X2) -> and#(active X1, X2))
        (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> active# X1)
        (active# if(X1, X2, X3) -> active# X1, active# if(X1, X2, X3) -> if#(active X1, X2, X3))
        (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> active# X1)
        (active# if(X1, X2, X3) -> active# X1, active# add(X1, X2) -> add#(active X1, X2))
        (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> add#(X, Y))
        (active# if(X1, X2, X3) -> active# X1, active# add(s X, Y) -> s# add(X, Y))
        (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X1)
        (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> active# X2)
        (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(X1, active X2))
        (active# if(X1, X2, X3) -> active# X1, active# first(X1, X2) -> first#(active X1, X2))
        (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> first#(X, Z))
        (active# if(X1, X2, X3) -> active# X1, active# first(s X, cons(Y, Z)) -> cons#(Y, first(X, Z)))
        (active# if(X1, X2, X3) -> active# X1, active# from X -> s# X)
        (active# if(X1, X2, X3) -> active# X1, active# from X -> cons#(X, from s X))
        (active# if(X1, X2, X3) -> active# X1, active# from X -> from# s X)
        (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(mark X1, X2, X3) -> if#(X1, X2, X3))
        (proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3), if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3))
        (active# from X -> cons#(X, from s X), cons#(ok X1, ok X2) -> cons#(X1, X2))
        (top# mark X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
        (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
        (top# mark X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
        (top# mark X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# add(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# s X -> s# proper X)
        (top# mark X -> proper# X, proper# s X -> proper# X)
        (top# mark X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# first(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (top# mark X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (top# mark X -> proper# X, proper# from X -> from# proper X)
        (top# mark X -> proper# X, proper# from X -> proper# X)
        (proper# s X -> proper# X, proper# and(X1, X2) -> and#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# and(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# if(X1, X2, X3) -> if#(proper X1, proper X2, proper X3))
        (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X1)
        (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X2)
        (proper# s X -> proper# X, proper# if(X1, X2, X3) -> proper# X3)
        (proper# s X -> proper# X, proper# add(X1, X2) -> add#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# add(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# s X -> s# proper X)
        (proper# s X -> proper# X, proper# s X -> proper# X)
        (proper# s X -> proper# X, proper# first(X1, X2) -> first#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# first(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
        (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
        (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
        (proper# s X -> proper# X, proper# from X -> from# proper X)
        (proper# s X -> proper# X, proper# from X -> proper# X)
        (s# ok X -> s# X, s# ok X -> s# X)
        (active# add(s X, Y) -> add#(X, Y), add#(mark X1, X2) -> add#(X1, X2))
        (active# add(s X, Y) -> add#(X, Y), add#(ok X1, ok X2) -> add#(X1, X2))
       }
       STATUS:
        arrows: 0.840513
        SCCS (10):
         Scc:
          {top# mark X -> top# proper X,
             top# ok X -> top# active X}
         Scc:
          {   active# and(X1, X2) -> active# X1,
           active# if(X1, X2, X3) -> active# X1,
              active# add(X1, X2) -> active# X1,
            active# first(X1, X2) -> active# X1,
            active# first(X1, X2) -> active# X2}
         Scc:
          {   proper# and(X1, X2) -> proper# X1,
              proper# and(X1, X2) -> proper# X2,
           proper# if(X1, X2, X3) -> proper# X1,
           proper# if(X1, X2, X3) -> proper# X2,
           proper# if(X1, X2, X3) -> proper# X3,
              proper# add(X1, X2) -> proper# X1,
              proper# add(X1, X2) -> proper# X2,
                      proper# s X -> proper# X,
            proper# first(X1, X2) -> proper# X1,
            proper# first(X1, X2) -> proper# X2,
             proper# cons(X1, X2) -> proper# X1,
             proper# cons(X1, X2) -> proper# X2,
                   proper# from X -> proper# X}
         Scc:
          {cons#(ok X1, ok X2) -> cons#(X1, X2)}
         Scc:
          { first#(X1, mark X2) -> first#(X1, X2),
            first#(mark X1, X2) -> first#(X1, X2),
           first#(ok X1, ok X2) -> first#(X1, X2)}
         Scc:
          {    if#(mark X1, X2, X3) -> if#(X1, X2, X3),
           if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3)}
         Scc:
          { and#(mark X1, X2) -> and#(X1, X2),
           and#(ok X1, ok X2) -> and#(X1, X2)}
         Scc:
          {from# ok X -> from# X}
         Scc:
          {s# ok X -> s# X}
         Scc:
          { add#(mark X1, X2) -> add#(X1, X2),
           add#(ok X1, ok X2) -> add#(X1, X2)}
         
         SCC (2):
          Strict:
           {top# mark X -> top# proper X,
              top# ok X -> top# active X}
          Weak:
          {           active and(X1, X2) -> and(active X1, X2),
                   active and(true(), X) -> mark X,
                  active and(false(), Y) -> mark false(),
                   active if(X1, X2, X3) -> if(active X1, X2, X3),
                 active if(true(), X, Y) -> mark X,
                active if(false(), X, Y) -> mark Y,
                      active add(X1, X2) -> add(active X1, X2),
                      active add(0(), X) -> mark X,
                      active add(s X, Y) -> mark s add(X, Y),
                    active first(X1, X2) -> first(X1, active X2),
                    active first(X1, X2) -> first(active X1, X2),
                    active first(0(), X) -> mark nil(),
           active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                           active from X -> mark cons(X, from s X),
                        and(mark X1, X2) -> mark and(X1, X2),
                       and(ok X1, ok X2) -> ok and(X1, X2),
                     if(mark X1, X2, X3) -> mark if(X1, X2, X3),
                 if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                        add(mark X1, X2) -> mark add(X1, X2),
                       add(ok X1, ok X2) -> ok add(X1, X2),
                                  s ok X -> ok s X,
                      first(X1, mark X2) -> mark first(X1, X2),
                      first(mark X1, X2) -> mark first(X1, X2),
                     first(ok X1, ok X2) -> ok first(X1, X2),
                      cons(ok X1, ok X2) -> ok cons(X1, X2),
                               from ok X -> ok from X,
                      proper and(X1, X2) -> and(proper X1, proper X2),
                           proper true() -> ok true(),
                          proper false() -> ok false(),
                   proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                      proper add(X1, X2) -> add(proper X1, proper X2),
                              proper 0() -> ok 0(),
                              proper s X -> s proper X,
                            proper nil() -> ok nil(),
                    proper first(X1, X2) -> first(proper X1, proper X2),
                     proper cons(X1, X2) -> cons(proper X1, proper X2),
                           proper from X -> from proper X,
                              top mark X -> top proper X,
                                top ok X -> top active X}
          POLY:
           Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
           Interpretation:
            [if](x0, x1, x2) = x0 + x1 + x2 + 1,
            
            [and](x0, x1) = x0 + x1 + 1,
            
            [add](x0, x1) = x0 + x1 + 1,
            
            [first](x0, x1) = x0 + x1,
            
            [cons](x0, x1) = 0,
            
            [mark](x0) = x0 + 1,
            
            [active](x0) = x0,
            
            [s](x0) = 1,
            
            [from](x0) = x0 + 1,
            
            [proper](x0) = x0,
            
            [ok](x0) = x0,
            
            [top](x0) = 0,
            
            [true] = 0,
            
            [false] = 0,
            
            [0] = 1,
            
            [nil] = 0,
            
            [top#](x0) = x0
           Strict:
            top# ok X -> top# active X
            0 + 1X >= 0 + 1X
            top# mark X -> top# proper X
            1 + 1X >= 0 + 1X
           Weak:
            top ok X -> top active X
            0 + 0X >= 0 + 0X
            top mark X -> top proper X
            0 + 0X >= 0 + 0X
            proper from X -> from proper X
            1 + 1X >= 1 + 1X
            proper cons(X1, X2) -> cons(proper X1, proper X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            proper first(X1, X2) -> first(proper X1, proper X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            proper nil() -> ok nil()
            0 >= 0
            proper s X -> s proper X
            1 + 0X >= 1 + 0X
            proper 0() -> ok 0()
            1 >= 1
            proper add(X1, X2) -> add(proper X1, proper X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
            1 + 1X1 + 1X2 + 1X3 >= 1 + 1X1 + 1X2 + 1X3
            proper false() -> ok false()
            0 >= 0
            proper true() -> ok true()
            0 >= 0
            proper and(X1, X2) -> and(proper X1, proper X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            from ok X -> ok from X
            1 + 1X >= 1 + 1X
            cons(ok X1, ok X2) -> ok cons(X1, X2)
            0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
            first(ok X1, ok X2) -> ok first(X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            first(mark X1, X2) -> mark first(X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            first(X1, mark X2) -> mark first(X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            s ok X -> ok s X
            1 + 0X >= 1 + 0X
            add(ok X1, ok X2) -> ok add(X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            add(mark X1, X2) -> mark add(X1, X2)
            2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
            if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
            1 + 1X1 + 1X2 + 1X3 >= 1 + 1X1 + 1X2 + 1X3
            if(mark X1, X2, X3) -> mark if(X1, X2, X3)
            2 + 1X1 + 1X2 + 1X3 >= 2 + 1X1 + 1X2 + 1X3
            and(ok X1, ok X2) -> ok and(X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            and(mark X1, X2) -> mark and(X1, X2)
            2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
            active from X -> mark cons(X, from s X)
            1 + 1X >= 1 + 0X
            active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
            1 + 0X + 0Y + 0Z >= 1 + 0X + 0Y + 0Z
            active first(0(), X) -> mark nil()
            1 + 1X >= 1
            active first(X1, X2) -> first(active X1, X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            active first(X1, X2) -> first(X1, active X2)
            0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
            active add(s X, Y) -> mark s add(X, Y)
            2 + 0X + 1Y >= 2 + 0X + 0Y
            active add(0(), X) -> mark X
            2 + 1X >= 1 + 1X
            active add(X1, X2) -> add(active X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
            active if(false(), X, Y) -> mark Y
            1 + 1X + 1Y >= 1 + 1Y
            active if(true(), X, Y) -> mark X
            1 + 1X + 1Y >= 1 + 1X
            active if(X1, X2, X3) -> if(active X1, X2, X3)
            1 + 1X1 + 1X2 + 1X3 >= 1 + 1X1 + 1X2 + 1X3
            active and(false(), Y) -> mark false()
            1 + 1Y >= 1
            active and(true(), X) -> mark X
            1 + 1X >= 1 + 1X
            active and(X1, X2) -> and(active X1, X2)
            1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
          SCCS (1):
           Scc:
            {top# ok X -> top# active X}
           
           SCC (1):
            Strict:
             {top# ok X -> top# active X}
            Weak:
            {           active and(X1, X2) -> and(active X1, X2),
                     active and(true(), X) -> mark X,
                    active and(false(), Y) -> mark false(),
                     active if(X1, X2, X3) -> if(active X1, X2, X3),
                   active if(true(), X, Y) -> mark X,
                  active if(false(), X, Y) -> mark Y,
                        active add(X1, X2) -> add(active X1, X2),
                        active add(0(), X) -> mark X,
                        active add(s X, Y) -> mark s add(X, Y),
                      active first(X1, X2) -> first(X1, active X2),
                      active first(X1, X2) -> first(active X1, X2),
                      active first(0(), X) -> mark nil(),
             active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                             active from X -> mark cons(X, from s X),
                          and(mark X1, X2) -> mark and(X1, X2),
                         and(ok X1, ok X2) -> ok and(X1, X2),
                       if(mark X1, X2, X3) -> mark if(X1, X2, X3),
                   if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                          add(mark X1, X2) -> mark add(X1, X2),
                         add(ok X1, ok X2) -> ok add(X1, X2),
                                    s ok X -> ok s X,
                        first(X1, mark X2) -> mark first(X1, X2),
                        first(mark X1, X2) -> mark first(X1, X2),
                       first(ok X1, ok X2) -> ok first(X1, X2),
                        cons(ok X1, ok X2) -> ok cons(X1, X2),
                                 from ok X -> ok from X,
                        proper and(X1, X2) -> and(proper X1, proper X2),
                             proper true() -> ok true(),
                            proper false() -> ok false(),
                     proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                        proper add(X1, X2) -> add(proper X1, proper X2),
                                proper 0() -> ok 0(),
                                proper s X -> s proper X,
                              proper nil() -> ok nil(),
                      proper first(X1, X2) -> first(proper X1, proper X2),
                       proper cons(X1, X2) -> cons(proper X1, proper X2),
                             proper from X -> from proper X,
                                top mark X -> top proper X,
                                  top ok X -> top active X}
            POLY:
             Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
             Interpretation:
              [if](x0, x1, x2) = x0,
              
              [and](x0, x1) = x0,
              
              [add](x0, x1) = x0 + 1,
              
              [first](x0, x1) = x0 + 1,
              
              [cons](x0, x1) = x0 + x1 + 1,
              
              [mark](x0) = 0,
              
              [active](x0) = x0,
              
              [s](x0) = x0 + 1,
              
              [from](x0) = x0,
              
              [proper](x0) = x0 + 1,
              
              [ok](x0) = x0 + 1,
              
              [top](x0) = 0,
              
              [true] = 0,
              
              [false] = 0,
              
              [0] = 0,
              
              [nil] = 1,
              
              [top#](x0) = x0
             Strict:
              top# ok X -> top# active X
              1 + 1X >= 0 + 1X
             Weak:
              top ok X -> top active X
              0 + 0X >= 0 + 0X
              top mark X -> top proper X
              0 + 0X >= 0 + 0X
              proper from X -> from proper X
              1 + 1X >= 1 + 1X
              proper cons(X1, X2) -> cons(proper X1, proper X2)
              2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
              proper first(X1, X2) -> first(proper X1, proper X2)
              2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
              proper nil() -> ok nil()
              2 >= 2
              proper s X -> s proper X
              2 + 1X >= 2 + 1X
              proper 0() -> ok 0()
              1 >= 1
              proper add(X1, X2) -> add(proper X1, proper X2)
              2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
              proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
              1 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
              proper false() -> ok false()
              1 >= 1
              proper true() -> ok true()
              1 >= 1
              proper and(X1, X2) -> and(proper X1, proper X2)
              1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
              from ok X -> ok from X
              1 + 1X >= 1 + 1X
              cons(ok X1, ok X2) -> ok cons(X1, X2)
              3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
              first(ok X1, ok X2) -> ok first(X1, X2)
              2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
              first(mark X1, X2) -> mark first(X1, X2)
              1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              first(X1, mark X2) -> mark first(X1, X2)
              1 + 1X1 + 0X2 >= 0 + 0X1 + 0X2
              s ok X -> ok s X
              2 + 1X >= 2 + 1X
              add(ok X1, ok X2) -> ok add(X1, X2)
              2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
              add(mark X1, X2) -> mark add(X1, X2)
              1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2
              if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
              1 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
              if(mark X1, X2, X3) -> mark if(X1, X2, X3)
              0 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
              and(ok X1, ok X2) -> ok and(X1, X2)
              1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
              and(mark X1, X2) -> mark and(X1, X2)
              0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
              active from X -> mark cons(X, from s X)
              0 + 1X >= 0 + 0X
              active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
              2 + 1X + 0Y + 0Z >= 0 + 0X + 0Y + 0Z
              active first(0(), X) -> mark nil()
              1 + 0X >= 0
              active first(X1, X2) -> first(active X1, X2)
              1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
              active first(X1, X2) -> first(X1, active X2)
              1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
              active add(s X, Y) -> mark s add(X, Y)
              1 + 0X + 1Y >= 0 + 0X + 0Y
              active add(0(), X) -> mark X
              1 + 1X >= 0 + 0X
              active add(X1, X2) -> add(active X1, X2)
              1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
              active if(false(), X, Y) -> mark Y
              0 + 0X + 0Y >= 0 + 0Y
              active if(true(), X, Y) -> mark X
              0 + 0X + 0Y >= 0 + 0X
              active if(X1, X2, X3) -> if(active X1, X2, X3)
              0 + 1X1 + 0X2 + 0X3 >= 0 + 1X1 + 0X2 + 0X3
              active and(false(), Y) -> mark false()
              0 + 0Y >= 0
              active and(true(), X) -> mark X
              0 + 0X >= 0 + 0X
              active and(X1, X2) -> and(active X1, X2)
              0 + 1X1 + 0X2 >= 0 + 1X1 + 0X2
            Qed
        
        SCC (5):
         Strict:
          {   active# and(X1, X2) -> active# X1,
           active# if(X1, X2, X3) -> active# X1,
              active# add(X1, X2) -> active# X1,
            active# first(X1, X2) -> active# X1,
            active# first(X1, X2) -> active# X2}
         Weak:
         {           active and(X1, X2) -> and(active X1, X2),
                  active and(true(), X) -> mark X,
                 active and(false(), Y) -> mark false(),
                  active if(X1, X2, X3) -> if(active X1, X2, X3),
                active if(true(), X, Y) -> mark X,
               active if(false(), X, Y) -> mark Y,
                     active add(X1, X2) -> add(active X1, X2),
                     active add(0(), X) -> mark X,
                     active add(s X, Y) -> mark s add(X, Y),
                   active first(X1, X2) -> first(X1, active X2),
                   active first(X1, X2) -> first(active X1, X2),
                   active first(0(), X) -> mark nil(),
          active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                          active from X -> mark cons(X, from s X),
                       and(mark X1, X2) -> mark and(X1, X2),
                      and(ok X1, ok X2) -> ok and(X1, X2),
                    if(mark X1, X2, X3) -> mark if(X1, X2, X3),
                if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                       add(mark X1, X2) -> mark add(X1, X2),
                      add(ok X1, ok X2) -> ok add(X1, X2),
                                 s ok X -> ok s X,
                     first(X1, mark X2) -> mark first(X1, X2),
                     first(mark X1, X2) -> mark first(X1, X2),
                    first(ok X1, ok X2) -> ok first(X1, X2),
                     cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from ok X -> ok from X,
                     proper and(X1, X2) -> and(proper X1, proper X2),
                          proper true() -> ok true(),
                         proper false() -> ok false(),
                  proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                     proper add(X1, X2) -> add(proper X1, proper X2),
                             proper 0() -> ok 0(),
                             proper s X -> s proper X,
                           proper nil() -> ok nil(),
                   proper first(X1, X2) -> first(proper X1, proper X2),
                    proper cons(X1, X2) -> cons(proper X1, proper X2),
                          proper from X -> from proper X,
                             top mark X -> top proper X,
                               top ok X -> top active X}
         POLY:
          Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
          Interpretation:
           [if](x0, x1, x2) = x0 + 1,
           
           [and](x0, x1) = x0 + 1,
           
           [add](x0, x1) = x0 + 1,
           
           [first](x0, x1) = x0 + x1 + 1,
           
           [cons](x0, x1) = x0 + 1,
           
           [mark](x0) = x0 + 1,
           
           [active](x0) = x0 + 1,
           
           [s](x0) = x0 + 1,
           
           [from](x0) = 0,
           
           [proper](x0) = 0,
           
           [ok](x0) = x0 + 1,
           
           [top](x0) = 0,
           
           [true] = 1,
           
           [false] = 1,
           
           [0] = 0,
           
           [nil] = 1,
           
           [active#](x0) = x0 + 1
          Strict:
           active# first(X1, X2) -> active# X2
           2 + 1X1 + 1X2 >= 1 + 1X2
           active# first(X1, X2) -> active# X1
           2 + 1X1 + 1X2 >= 1 + 1X1
           active# add(X1, X2) -> active# X1
           2 + 1X1 + 0X2 >= 1 + 1X1
           active# if(X1, X2, X3) -> active# X1
           2 + 1X1 + 0X2 + 0X3 >= 1 + 1X1
           active# and(X1, X2) -> active# X1
           2 + 1X1 + 0X2 >= 1 + 1X1
          Weak:
           top ok X -> top active X
           0 + 0X >= 0 + 0X
           top mark X -> top proper X
           0 + 0X >= 0 + 0X
           proper from X -> from proper X
           0 + 0X >= 0 + 0X
           proper cons(X1, X2) -> cons(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper first(X1, X2) -> first(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper nil() -> ok nil()
           0 >= 2
           proper s X -> s proper X
           0 + 0X >= 1 + 0X
           proper 0() -> ok 0()
           0 >= 1
           proper add(X1, X2) -> add(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
           0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
           proper false() -> ok false()
           0 >= 2
           proper true() -> ok true()
           0 >= 2
           proper and(X1, X2) -> and(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           from ok X -> ok from X
           0 + 0X >= 1 + 0X
           cons(ok X1, ok X2) -> ok cons(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           first(ok X1, ok X2) -> ok first(X1, X2)
           3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           first(mark X1, X2) -> mark first(X1, X2)
           2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           first(X1, mark X2) -> mark first(X1, X2)
           2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           s ok X -> ok s X
           2 + 1X >= 2 + 1X
           add(ok X1, ok X2) -> ok add(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           add(mark X1, X2) -> mark add(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
           2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
           if(mark X1, X2, X3) -> mark if(X1, X2, X3)
           2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
           and(ok X1, ok X2) -> ok and(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           and(mark X1, X2) -> mark and(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           active from X -> mark cons(X, from s X)
           1 + 0X >= 2 + 0X
           active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
           4 + 1X + 0Y + 1Z >= 3 + 1X + 0Y + 1Z
           active first(0(), X) -> mark nil()
           2 + 1X >= 2
           active first(X1, X2) -> first(active X1, X2)
           2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           active first(X1, X2) -> first(X1, active X2)
           2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           active add(s X, Y) -> mark s add(X, Y)
           3 + 1X + 0Y >= 3 + 1X + 0Y
           active add(0(), X) -> mark X
           2 + 0X >= 1 + 1X
           active add(X1, X2) -> add(active X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           active if(false(), X, Y) -> mark Y
           3 + 0X + 0Y >= 1 + 1Y
           active if(true(), X, Y) -> mark X
           3 + 0X + 0Y >= 1 + 1X
           active if(X1, X2, X3) -> if(active X1, X2, X3)
           2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
           active and(false(), Y) -> mark false()
           3 + 0Y >= 2
           active and(true(), X) -> mark X
           3 + 0X >= 1 + 1X
           active and(X1, X2) -> and(active X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         Qed
       
       
       
       
       
       
       
       
       
       
       
       SCC (13):
        Strict:
         {   proper# and(X1, X2) -> proper# X1,
             proper# and(X1, X2) -> proper# X2,
          proper# if(X1, X2, X3) -> proper# X1,
          proper# if(X1, X2, X3) -> proper# X2,
          proper# if(X1, X2, X3) -> proper# X3,
             proper# add(X1, X2) -> proper# X1,
             proper# add(X1, X2) -> proper# X2,
                     proper# s X -> proper# X,
           proper# first(X1, X2) -> proper# X1,
           proper# first(X1, X2) -> proper# X2,
            proper# cons(X1, X2) -> proper# X1,
            proper# cons(X1, X2) -> proper# X2,
                  proper# from X -> proper# X}
        Weak:
        {           active and(X1, X2) -> and(active X1, X2),
                 active and(true(), X) -> mark X,
                active and(false(), Y) -> mark false(),
                 active if(X1, X2, X3) -> if(active X1, X2, X3),
               active if(true(), X, Y) -> mark X,
              active if(false(), X, Y) -> mark Y,
                    active add(X1, X2) -> add(active X1, X2),
                    active add(0(), X) -> mark X,
                    active add(s X, Y) -> mark s add(X, Y),
                  active first(X1, X2) -> first(X1, active X2),
                  active first(X1, X2) -> first(active X1, X2),
                  active first(0(), X) -> mark nil(),
         active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                         active from X -> mark cons(X, from s X),
                      and(mark X1, X2) -> mark and(X1, X2),
                     and(ok X1, ok X2) -> ok and(X1, X2),
                   if(mark X1, X2, X3) -> mark if(X1, X2, X3),
               if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                      add(mark X1, X2) -> mark add(X1, X2),
                     add(ok X1, ok X2) -> ok add(X1, X2),
                                s ok X -> ok s X,
                    first(X1, mark X2) -> mark first(X1, X2),
                    first(mark X1, X2) -> mark first(X1, X2),
                   first(ok X1, ok X2) -> ok first(X1, X2),
                    cons(ok X1, ok X2) -> ok cons(X1, X2),
                             from ok X -> ok from X,
                    proper and(X1, X2) -> and(proper X1, proper X2),
                         proper true() -> ok true(),
                        proper false() -> ok false(),
                 proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                    proper add(X1, X2) -> add(proper X1, proper X2),
                            proper 0() -> ok 0(),
                            proper s X -> s proper X,
                          proper nil() -> ok nil(),
                  proper first(X1, X2) -> first(proper X1, proper X2),
                   proper cons(X1, X2) -> cons(proper X1, proper X2),
                         proper from X -> from proper X,
                            top mark X -> top proper X,
                              top ok X -> top active X}
        POLY:
         Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
         Interpretation:
          [if](x0, x1, x2) = x0 + x1 + x2 + 1,
          
          [and](x0, x1) = x0 + x1 + 1,
          
          [add](x0, x1) = x0 + x1 + 1,
          
          [first](x0, x1) = x0 + x1 + 1,
          
          [cons](x0, x1) = x0 + x1 + 1,
          
          [mark](x0) = x0,
          
          [active](x0) = x0 + 1,
          
          [s](x0) = x0 + 1,
          
          [from](x0) = x0 + 1,
          
          [proper](x0) = 0,
          
          [ok](x0) = 0,
          
          [top](x0) = 0,
          
          [true] = 0,
          
          [false] = 0,
          
          [0] = 0,
          
          [nil] = 0,
          
          [proper#](x0) = x0 + 1
         Strict:
          proper# from X -> proper# X
          2 + 1X >= 1 + 1X
          proper# cons(X1, X2) -> proper# X2
          2 + 1X1 + 1X2 >= 1 + 1X2
          proper# cons(X1, X2) -> proper# X1
          2 + 1X1 + 1X2 >= 1 + 1X1
          proper# first(X1, X2) -> proper# X2
          2 + 1X1 + 1X2 >= 1 + 1X2
          proper# first(X1, X2) -> proper# X1
          2 + 1X1 + 1X2 >= 1 + 1X1
          proper# s X -> proper# X
          2 + 1X >= 1 + 1X
          proper# add(X1, X2) -> proper# X2
          2 + 1X1 + 1X2 >= 1 + 1X2
          proper# add(X1, X2) -> proper# X1
          2 + 1X1 + 1X2 >= 1 + 1X1
          proper# if(X1, X2, X3) -> proper# X3
          2 + 1X1 + 1X2 + 1X3 >= 1 + 1X3
          proper# if(X1, X2, X3) -> proper# X2
          2 + 1X1 + 1X2 + 1X3 >= 1 + 1X2
          proper# if(X1, X2, X3) -> proper# X1
          2 + 1X1 + 1X2 + 1X3 >= 1 + 1X1
          proper# and(X1, X2) -> proper# X2
          2 + 1X1 + 1X2 >= 1 + 1X2
          proper# and(X1, X2) -> proper# X1
          2 + 1X1 + 1X2 >= 1 + 1X1
         Weak:
          top ok X -> top active X
          0 + 0X >= 0 + 0X
          top mark X -> top proper X
          0 + 0X >= 0 + 0X
          proper from X -> from proper X
          0 + 0X >= 1 + 0X
          proper cons(X1, X2) -> cons(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper first(X1, X2) -> first(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper nil() -> ok nil()
          0 >= 0
          proper s X -> s proper X
          0 + 0X >= 1 + 0X
          proper 0() -> ok 0()
          0 >= 0
          proper add(X1, X2) -> add(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
          0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
          proper false() -> ok false()
          0 >= 0
          proper true() -> ok true()
          0 >= 0
          proper and(X1, X2) -> and(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          from ok X -> ok from X
          1 + 0X >= 0 + 0X
          cons(ok X1, ok X2) -> ok cons(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          first(ok X1, ok X2) -> ok first(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          first(mark X1, X2) -> mark first(X1, X2)
          1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
          first(X1, mark X2) -> mark first(X1, X2)
          1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
          s ok X -> ok s X
          1 + 0X >= 0 + 0X
          add(ok X1, ok X2) -> ok add(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          add(mark X1, X2) -> mark add(X1, X2)
          1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
          if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
          1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
          if(mark X1, X2, X3) -> mark if(X1, X2, X3)
          1 + 1X1 + 1X2 + 1X3 >= 1 + 1X1 + 1X2 + 1X3
          and(ok X1, ok X2) -> ok and(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          and(mark X1, X2) -> mark and(X1, X2)
          1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
          active from X -> mark cons(X, from s X)
          2 + 1X >= 3 + 2X
          active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
          4 + 1X + 1Y + 1Z >= 2 + 1X + 1Y + 1Z
          active first(0(), X) -> mark nil()
          2 + 1X >= 0
          active first(X1, X2) -> first(active X1, X2)
          2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
          active first(X1, X2) -> first(X1, active X2)
          2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
          active add(s X, Y) -> mark s add(X, Y)
          3 + 1X + 1Y >= 2 + 1X + 1Y
          active add(0(), X) -> mark X
          2 + 1X >= 0 + 1X
          active add(X1, X2) -> add(active X1, X2)
          2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
          active if(false(), X, Y) -> mark Y
          2 + 1X + 1Y >= 0 + 1Y
          active if(true(), X, Y) -> mark X
          2 + 1X + 1Y >= 0 + 1X
          active if(X1, X2, X3) -> if(active X1, X2, X3)
          2 + 1X1 + 1X2 + 1X3 >= 2 + 1X1 + 1X2 + 1X3
          active and(false(), Y) -> mark false()
          2 + 1Y >= 0
          active and(true(), X) -> mark X
          2 + 1X >= 0 + 1X
          active and(X1, X2) -> and(active X1, X2)
          2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
        Qed
       
       
       SCC (1):
        Strict:
         {cons#(ok X1, ok X2) -> cons#(X1, X2)}
        Weak:
        {           active and(X1, X2) -> and(active X1, X2),
                 active and(true(), X) -> mark X,
                active and(false(), Y) -> mark false(),
                 active if(X1, X2, X3) -> if(active X1, X2, X3),
               active if(true(), X, Y) -> mark X,
              active if(false(), X, Y) -> mark Y,
                    active add(X1, X2) -> add(active X1, X2),
                    active add(0(), X) -> mark X,
                    active add(s X, Y) -> mark s add(X, Y),
                  active first(X1, X2) -> first(X1, active X2),
                  active first(X1, X2) -> first(active X1, X2),
                  active first(0(), X) -> mark nil(),
         active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                         active from X -> mark cons(X, from s X),
                      and(mark X1, X2) -> mark and(X1, X2),
                     and(ok X1, ok X2) -> ok and(X1, X2),
                   if(mark X1, X2, X3) -> mark if(X1, X2, X3),
               if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                      add(mark X1, X2) -> mark add(X1, X2),
                     add(ok X1, ok X2) -> ok add(X1, X2),
                                s ok X -> ok s X,
                    first(X1, mark X2) -> mark first(X1, X2),
                    first(mark X1, X2) -> mark first(X1, X2),
                   first(ok X1, ok X2) -> ok first(X1, X2),
                    cons(ok X1, ok X2) -> ok cons(X1, X2),
                             from ok X -> ok from X,
                    proper and(X1, X2) -> and(proper X1, proper X2),
                         proper true() -> ok true(),
                        proper false() -> ok false(),
                 proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                    proper add(X1, X2) -> add(proper X1, proper X2),
                            proper 0() -> ok 0(),
                            proper s X -> s proper X,
                          proper nil() -> ok nil(),
                  proper first(X1, X2) -> first(proper X1, proper X2),
                   proper cons(X1, X2) -> cons(proper X1, proper X2),
                         proper from X -> from proper X,
                            top mark X -> top proper X,
                              top ok X -> top active X}
        POLY:
         Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
         Interpretation:
          [if](x0, x1, x2) = x0 + 1,
          
          [and](x0, x1) = x0 + 1,
          
          [add](x0, x1) = x0 + 1,
          
          [first](x0, x1) = x0 + 1,
          
          [cons](x0, x1) = x0 + 1,
          
          [mark](x0) = x0,
          
          [active](x0) = x0 + 1,
          
          [s](x0) = x0 + 1,
          
          [from](x0) = 1,
          
          [proper](x0) = 0,
          
          [ok](x0) = x0 + 1,
          
          [top](x0) = 0,
          
          [true] = 0,
          
          [false] = 0,
          
          [0] = 0,
          
          [nil] = 0,
          
          [cons#](x0, x1) = x0
         Strict:
          cons#(ok X1, ok X2) -> cons#(X1, X2)
          1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
         Weak:
          top ok X -> top active X
          0 + 0X >= 0 + 0X
          top mark X -> top proper X
          0 + 0X >= 0 + 0X
          proper from X -> from proper X
          0 + 0X >= 1 + 0X
          proper cons(X1, X2) -> cons(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper first(X1, X2) -> first(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper nil() -> ok nil()
          0 >= 1
          proper s X -> s proper X
          0 + 0X >= 1 + 0X
          proper 0() -> ok 0()
          0 >= 1
          proper add(X1, X2) -> add(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
          0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
          proper false() -> ok false()
          0 >= 1
          proper true() -> ok true()
          0 >= 1
          proper and(X1, X2) -> and(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          from ok X -> ok from X
          1 + 0X >= 2 + 0X
          cons(ok X1, ok X2) -> ok cons(X1, X2)
          2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
          first(ok X1, ok X2) -> ok first(X1, X2)
          2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
          first(mark X1, X2) -> mark first(X1, X2)
          1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
          first(X1, mark X2) -> mark first(X1, X2)
          1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
          s ok X -> ok s X
          2 + 1X >= 2 + 1X
          add(ok X1, ok X2) -> ok add(X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
          add(mark X1, X2) -> mark add(X1, X2)
          1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
          if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
          2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
          if(mark X1, X2, X3) -> mark if(X1, X2, X3)
          1 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
          and(ok X1, ok X2) -> ok and(X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
          and(mark X1, X2) -> mark and(X1, X2)
          1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
          active from X -> mark cons(X, from s X)
          2 + 0X >= 2 + 0X
          active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
          3 + 0X + 0Y + 1Z >= 2 + 0X + 0Y + 1Z
          active first(0(), X) -> mark nil()
          2 + 1X >= 0
          active first(X1, X2) -> first(active X1, X2)
          2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
          active first(X1, X2) -> first(X1, active X2)
          2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
          active add(s X, Y) -> mark s add(X, Y)
          3 + 1X + 0Y >= 2 + 1X + 0Y
          active add(0(), X) -> mark X
          2 + 0X >= 0 + 1X
          active add(X1, X2) -> add(active X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
          active if(false(), X, Y) -> mark Y
          2 + 0X + 0Y >= 0 + 1Y
          active if(true(), X, Y) -> mark X
          2 + 0X + 0Y >= 0 + 1X
          active if(X1, X2, X3) -> if(active X1, X2, X3)
          2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
          active and(false(), Y) -> mark false()
          2 + 0Y >= 0
          active and(true(), X) -> mark X
          2 + 0X >= 0 + 1X
          active and(X1, X2) -> and(active X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        Qed
      
      SCC (3):
       Strict:
        { first#(X1, mark X2) -> first#(X1, X2),
          first#(mark X1, X2) -> first#(X1, X2),
         first#(ok X1, ok X2) -> first#(X1, X2)}
       Weak:
       {           active and(X1, X2) -> and(active X1, X2),
                active and(true(), X) -> mark X,
               active and(false(), Y) -> mark false(),
                active if(X1, X2, X3) -> if(active X1, X2, X3),
              active if(true(), X, Y) -> mark X,
             active if(false(), X, Y) -> mark Y,
                   active add(X1, X2) -> add(active X1, X2),
                   active add(0(), X) -> mark X,
                   active add(s X, Y) -> mark s add(X, Y),
                 active first(X1, X2) -> first(X1, active X2),
                 active first(X1, X2) -> first(active X1, X2),
                 active first(0(), X) -> mark nil(),
        active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                        active from X -> mark cons(X, from s X),
                     and(mark X1, X2) -> mark and(X1, X2),
                    and(ok X1, ok X2) -> ok and(X1, X2),
                  if(mark X1, X2, X3) -> mark if(X1, X2, X3),
              if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                     add(mark X1, X2) -> mark add(X1, X2),
                    add(ok X1, ok X2) -> ok add(X1, X2),
                               s ok X -> ok s X,
                   first(X1, mark X2) -> mark first(X1, X2),
                   first(mark X1, X2) -> mark first(X1, X2),
                  first(ok X1, ok X2) -> ok first(X1, X2),
                   cons(ok X1, ok X2) -> ok cons(X1, X2),
                            from ok X -> ok from X,
                   proper and(X1, X2) -> and(proper X1, proper X2),
                        proper true() -> ok true(),
                       proper false() -> ok false(),
                proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                   proper add(X1, X2) -> add(proper X1, proper X2),
                           proper 0() -> ok 0(),
                           proper s X -> s proper X,
                         proper nil() -> ok nil(),
                 proper first(X1, X2) -> first(proper X1, proper X2),
                  proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper from X -> from proper X,
                           top mark X -> top proper X,
                             top ok X -> top active X}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [if](x0, x1, x2) = 0,
         
         [and](x0, x1) = x0 + 1,
         
         [add](x0, x1) = x0 + 1,
         
         [first](x0, x1) = x0 + 1,
         
         [cons](x0, x1) = x0 + 1,
         
         [mark](x0) = x0 + 1,
         
         [active](x0) = x0 + 1,
         
         [s](x0) = x0 + 1,
         
         [from](x0) = 0,
         
         [proper](x0) = x0 + 1,
         
         [ok](x0) = x0 + 1,
         
         [top](x0) = 0,
         
         [true] = 0,
         
         [false] = 0,
         
         [0] = 0,
         
         [nil] = 1,
         
         [first#](x0, x1) = x0 + 1
        Strict:
         first#(ok X1, ok X2) -> first#(X1, X2)
         2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
         first#(mark X1, X2) -> first#(X1, X2)
         2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
         first#(X1, mark X2) -> first#(X1, X2)
         1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
        Weak:
         top ok X -> top active X
         0 + 0X >= 0 + 0X
         top mark X -> top proper X
         0 + 0X >= 0 + 0X
         proper from X -> from proper X
         1 + 0X >= 0 + 0X
         proper cons(X1, X2) -> cons(proper X1, proper X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         proper first(X1, X2) -> first(proper X1, proper X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         proper nil() -> ok nil()
         2 >= 2
         proper s X -> s proper X
         2 + 1X >= 2 + 1X
         proper 0() -> ok 0()
         1 >= 1
         proper add(X1, X2) -> add(proper X1, proper X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
         1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
         proper false() -> ok false()
         1 >= 1
         proper true() -> ok true()
         1 >= 1
         proper and(X1, X2) -> and(proper X1, proper X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         from ok X -> ok from X
         0 + 0X >= 1 + 0X
         cons(ok X1, ok X2) -> ok cons(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         first(ok X1, ok X2) -> ok first(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         first(mark X1, X2) -> mark first(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         first(X1, mark X2) -> mark first(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         s ok X -> ok s X
         2 + 1X >= 2 + 1X
         add(ok X1, ok X2) -> ok add(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         add(mark X1, X2) -> mark add(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
         0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
         if(mark X1, X2, X3) -> mark if(X1, X2, X3)
         0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
         and(ok X1, ok X2) -> ok and(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         and(mark X1, X2) -> mark and(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         active from X -> mark cons(X, from s X)
         1 + 0X >= 2 + 0X
         active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
         3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
         active first(0(), X) -> mark nil()
         2 + 1X >= 2
         active first(X1, X2) -> first(active X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
         active first(X1, X2) -> first(X1, active X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         active add(s X, Y) -> mark s add(X, Y)
         3 + 1X + 0Y >= 3 + 1X + 0Y
         active add(0(), X) -> mark X
         2 + 0X >= 1 + 1X
         active add(X1, X2) -> add(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         active if(false(), X, Y) -> mark Y
         1 + 0X + 0Y >= 1 + 1Y
         active if(true(), X, Y) -> mark X
         1 + 0X + 0Y >= 1 + 1X
         active if(X1, X2, X3) -> if(active X1, X2, X3)
         1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
         active and(false(), Y) -> mark false()
         2 + 0Y >= 1
         active and(true(), X) -> mark X
         2 + 0X >= 1 + 1X
         active and(X1, X2) -> and(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       SCCS (1):
        Scc:
         {first#(X1, mark X2) -> first#(X1, X2)}
        
        SCC (1):
         Strict:
          {first#(X1, mark X2) -> first#(X1, X2)}
         Weak:
         {           active and(X1, X2) -> and(active X1, X2),
                  active and(true(), X) -> mark X,
                 active and(false(), Y) -> mark false(),
                  active if(X1, X2, X3) -> if(active X1, X2, X3),
                active if(true(), X, Y) -> mark X,
               active if(false(), X, Y) -> mark Y,
                     active add(X1, X2) -> add(active X1, X2),
                     active add(0(), X) -> mark X,
                     active add(s X, Y) -> mark s add(X, Y),
                   active first(X1, X2) -> first(X1, active X2),
                   active first(X1, X2) -> first(active X1, X2),
                   active first(0(), X) -> mark nil(),
          active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                          active from X -> mark cons(X, from s X),
                       and(mark X1, X2) -> mark and(X1, X2),
                      and(ok X1, ok X2) -> ok and(X1, X2),
                    if(mark X1, X2, X3) -> mark if(X1, X2, X3),
                if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                       add(mark X1, X2) -> mark add(X1, X2),
                      add(ok X1, ok X2) -> ok add(X1, X2),
                                 s ok X -> ok s X,
                     first(X1, mark X2) -> mark first(X1, X2),
                     first(mark X1, X2) -> mark first(X1, X2),
                    first(ok X1, ok X2) -> ok first(X1, X2),
                     cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from ok X -> ok from X,
                     proper and(X1, X2) -> and(proper X1, proper X2),
                          proper true() -> ok true(),
                         proper false() -> ok false(),
                  proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                     proper add(X1, X2) -> add(proper X1, proper X2),
                             proper 0() -> ok 0(),
                             proper s X -> s proper X,
                           proper nil() -> ok nil(),
                   proper first(X1, X2) -> first(proper X1, proper X2),
                    proper cons(X1, X2) -> cons(proper X1, proper X2),
                          proper from X -> from proper X,
                             top mark X -> top proper X,
                               top ok X -> top active X}
         POLY:
          Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
          Interpretation:
           [if](x0, x1, x2) = x0 + 1,
           
           [and](x0, x1) = x0 + 1,
           
           [add](x0, x1) = x0 + 1,
           
           [first](x0, x1) = x0 + 1,
           
           [cons](x0, x1) = x0 + 1,
           
           [mark](x0) = x0 + 1,
           
           [active](x0) = x0 + 1,
           
           [s](x0) = x0 + 1,
           
           [from](x0) = 0,
           
           [proper](x0) = 0,
           
           [ok](x0) = 0,
           
           [top](x0) = x0 + 1,
           
           [true] = 0,
           
           [false] = 0,
           
           [0] = 0,
           
           [nil] = 1,
           
           [first#](x0, x1) = x0 + 1
          Strict:
           first#(X1, mark X2) -> first#(X1, X2)
           2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
          Weak:
           top ok X -> top active X
           1 + 0X >= 2 + 1X
           top mark X -> top proper X
           2 + 1X >= 1 + 0X
           proper from X -> from proper X
           0 + 0X >= 0 + 0X
           proper cons(X1, X2) -> cons(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper first(X1, X2) -> first(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper nil() -> ok nil()
           0 >= 0
           proper s X -> s proper X
           0 + 0X >= 1 + 0X
           proper 0() -> ok 0()
           0 >= 0
           proper add(X1, X2) -> add(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
           0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
           proper false() -> ok false()
           0 >= 0
           proper true() -> ok true()
           0 >= 0
           proper and(X1, X2) -> and(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           from ok X -> ok from X
           0 + 0X >= 0 + 0X
           cons(ok X1, ok X2) -> ok cons(X1, X2)
           1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           first(ok X1, ok X2) -> ok first(X1, X2)
           1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           first(mark X1, X2) -> mark first(X1, X2)
           1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           first(X1, mark X2) -> mark first(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           s ok X -> ok s X
           1 + 0X >= 0 + 0X
           add(ok X1, ok X2) -> ok add(X1, X2)
           1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           add(mark X1, X2) -> mark add(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
           1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
           if(mark X1, X2, X3) -> mark if(X1, X2, X3)
           2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
           and(ok X1, ok X2) -> ok and(X1, X2)
           1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           and(mark X1, X2) -> mark and(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           active from X -> mark cons(X, from s X)
           1 + 0X >= 2 + 0X
           active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
           3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
           active first(0(), X) -> mark nil()
           2 + 1X >= 2
           active first(X1, X2) -> first(active X1, X2)
           2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
           active first(X1, X2) -> first(X1, active X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           active add(s X, Y) -> mark s add(X, Y)
           3 + 1X + 0Y >= 3 + 1X + 0Y
           active add(0(), X) -> mark X
           2 + 0X >= 1 + 1X
           active add(X1, X2) -> add(active X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           active if(false(), X, Y) -> mark Y
           2 + 0X + 0Y >= 1 + 1Y
           active if(true(), X, Y) -> mark X
           2 + 0X + 0Y >= 1 + 1X
           active if(X1, X2, X3) -> if(active X1, X2, X3)
           2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
           active and(false(), Y) -> mark false()
           2 + 0Y >= 1
           active and(true(), X) -> mark X
           2 + 0X >= 1 + 1X
           active and(X1, X2) -> and(active X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         Qed
     
     
     
     SCC (2):
      Strict:
       {    if#(mark X1, X2, X3) -> if#(X1, X2, X3),
        if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3)}
      Weak:
      {           active and(X1, X2) -> and(active X1, X2),
               active and(true(), X) -> mark X,
              active and(false(), Y) -> mark false(),
               active if(X1, X2, X3) -> if(active X1, X2, X3),
             active if(true(), X, Y) -> mark X,
            active if(false(), X, Y) -> mark Y,
                  active add(X1, X2) -> add(active X1, X2),
                  active add(0(), X) -> mark X,
                  active add(s X, Y) -> mark s add(X, Y),
                active first(X1, X2) -> first(X1, active X2),
                active first(X1, X2) -> first(active X1, X2),
                active first(0(), X) -> mark nil(),
       active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                       active from X -> mark cons(X, from s X),
                    and(mark X1, X2) -> mark and(X1, X2),
                   and(ok X1, ok X2) -> ok and(X1, X2),
                 if(mark X1, X2, X3) -> mark if(X1, X2, X3),
             if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                    add(mark X1, X2) -> mark add(X1, X2),
                   add(ok X1, ok X2) -> ok add(X1, X2),
                              s ok X -> ok s X,
                  first(X1, mark X2) -> mark first(X1, X2),
                  first(mark X1, X2) -> mark first(X1, X2),
                 first(ok X1, ok X2) -> ok first(X1, X2),
                  cons(ok X1, ok X2) -> ok cons(X1, X2),
                           from ok X -> ok from X,
                  proper and(X1, X2) -> and(proper X1, proper X2),
                       proper true() -> ok true(),
                      proper false() -> ok false(),
               proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                  proper add(X1, X2) -> add(proper X1, proper X2),
                          proper 0() -> ok 0(),
                          proper s X -> s proper X,
                        proper nil() -> ok nil(),
                proper first(X1, X2) -> first(proper X1, proper X2),
                 proper cons(X1, X2) -> cons(proper X1, proper X2),
                       proper from X -> from proper X,
                          top mark X -> top proper X,
                            top ok X -> top active X}
      POLY:
       Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
       Interpretation:
        [if](x0, x1, x2) = x0 + 1,
        
        [and](x0, x1) = x0 + 1,
        
        [add](x0, x1) = x0 + 1,
        
        [first](x0, x1) = x0 + 1,
        
        [cons](x0, x1) = x0 + 1,
        
        [mark](x0) = x0,
        
        [active](x0) = x0 + 1,
        
        [s](x0) = x0 + 1,
        
        [from](x0) = 1,
        
        [proper](x0) = 0,
        
        [ok](x0) = x0 + 1,
        
        [top](x0) = x0,
        
        [true] = 0,
        
        [false] = 0,
        
        [0] = 0,
        
        [nil] = 0,
        
        [if#](x0, x1, x2) = x0
       Strict:
        if#(ok X1, ok X2, ok X3) -> if#(X1, X2, X3)
        1 + 0X1 + 0X2 + 1X3 >= 0 + 0X1 + 0X2 + 1X3
        if#(mark X1, X2, X3) -> if#(X1, X2, X3)
        0 + 0X1 + 0X2 + 1X3 >= 0 + 0X1 + 0X2 + 1X3
       Weak:
        top ok X -> top active X
        1 + 1X >= 1 + 1X
        top mark X -> top proper X
        0 + 1X >= 0 + 0X
        proper from X -> from proper X
        0 + 0X >= 1 + 0X
        proper cons(X1, X2) -> cons(proper X1, proper X2)
        0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
        proper first(X1, X2) -> first(proper X1, proper X2)
        0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
        proper nil() -> ok nil()
        0 >= 1
        proper s X -> s proper X
        0 + 0X >= 1 + 0X
        proper 0() -> ok 0()
        0 >= 1
        proper add(X1, X2) -> add(proper X1, proper X2)
        0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
        proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
        0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
        proper false() -> ok false()
        0 >= 1
        proper true() -> ok true()
        0 >= 1
        proper and(X1, X2) -> and(proper X1, proper X2)
        0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
        from ok X -> ok from X
        1 + 0X >= 2 + 0X
        cons(ok X1, ok X2) -> ok cons(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        first(ok X1, ok X2) -> ok first(X1, X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        first(mark X1, X2) -> mark first(X1, X2)
        1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        first(X1, mark X2) -> mark first(X1, X2)
        1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        s ok X -> ok s X
        2 + 1X >= 2 + 1X
        add(ok X1, ok X2) -> ok add(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        add(mark X1, X2) -> mark add(X1, X2)
        1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
        if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
        2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
        if(mark X1, X2, X3) -> mark if(X1, X2, X3)
        1 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
        and(ok X1, ok X2) -> ok and(X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        and(mark X1, X2) -> mark and(X1, X2)
        1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
        active from X -> mark cons(X, from s X)
        2 + 0X >= 2 + 0X
        active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
        3 + 0X + 0Y + 1Z >= 2 + 0X + 0Y + 1Z
        active first(0(), X) -> mark nil()
        2 + 1X >= 0
        active first(X1, X2) -> first(active X1, X2)
        2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
        active first(X1, X2) -> first(X1, active X2)
        2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
        active add(s X, Y) -> mark s add(X, Y)
        3 + 1X + 0Y >= 2 + 1X + 0Y
        active add(0(), X) -> mark X
        2 + 0X >= 0 + 1X
        active add(X1, X2) -> add(active X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        active if(false(), X, Y) -> mark Y
        2 + 0X + 0Y >= 0 + 1Y
        active if(true(), X, Y) -> mark X
        2 + 0X + 0Y >= 0 + 1X
        active if(X1, X2, X3) -> if(active X1, X2, X3)
        2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
        active and(false(), Y) -> mark false()
        2 + 0Y >= 0
        active and(true(), X) -> mark X
        2 + 0X >= 0 + 1X
        active and(X1, X2) -> and(active X1, X2)
        2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      SCCS (1):
       Scc:
        {if#(mark X1, X2, X3) -> if#(X1, X2, X3)}
       
       SCC (1):
        Strict:
         {if#(mark X1, X2, X3) -> if#(X1, X2, X3)}
        Weak:
        {           active and(X1, X2) -> and(active X1, X2),
                 active and(true(), X) -> mark X,
                active and(false(), Y) -> mark false(),
                 active if(X1, X2, X3) -> if(active X1, X2, X3),
               active if(true(), X, Y) -> mark X,
              active if(false(), X, Y) -> mark Y,
                    active add(X1, X2) -> add(active X1, X2),
                    active add(0(), X) -> mark X,
                    active add(s X, Y) -> mark s add(X, Y),
                  active first(X1, X2) -> first(X1, active X2),
                  active first(X1, X2) -> first(active X1, X2),
                  active first(0(), X) -> mark nil(),
         active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                         active from X -> mark cons(X, from s X),
                      and(mark X1, X2) -> mark and(X1, X2),
                     and(ok X1, ok X2) -> ok and(X1, X2),
                   if(mark X1, X2, X3) -> mark if(X1, X2, X3),
               if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                      add(mark X1, X2) -> mark add(X1, X2),
                     add(ok X1, ok X2) -> ok add(X1, X2),
                                s ok X -> ok s X,
                    first(X1, mark X2) -> mark first(X1, X2),
                    first(mark X1, X2) -> mark first(X1, X2),
                   first(ok X1, ok X2) -> ok first(X1, X2),
                    cons(ok X1, ok X2) -> ok cons(X1, X2),
                             from ok X -> ok from X,
                    proper and(X1, X2) -> and(proper X1, proper X2),
                         proper true() -> ok true(),
                        proper false() -> ok false(),
                 proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                    proper add(X1, X2) -> add(proper X1, proper X2),
                            proper 0() -> ok 0(),
                            proper s X -> s proper X,
                          proper nil() -> ok nil(),
                  proper first(X1, X2) -> first(proper X1, proper X2),
                   proper cons(X1, X2) -> cons(proper X1, proper X2),
                         proper from X -> from proper X,
                            top mark X -> top proper X,
                              top ok X -> top active X}
        POLY:
         Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
         Interpretation:
          [if](x0, x1, x2) = x0 + 1,
          
          [and](x0, x1) = x0 + 1,
          
          [add](x0, x1) = x0 + 1,
          
          [first](x0, x1) = x0 + 1,
          
          [cons](x0, x1) = x0 + 1,
          
          [mark](x0) = x0 + 1,
          
          [active](x0) = x0 + 1,
          
          [s](x0) = x0 + 1,
          
          [from](x0) = 0,
          
          [proper](x0) = 0,
          
          [ok](x0) = 0,
          
          [top](x0) = x0 + 1,
          
          [true] = 0,
          
          [false] = 0,
          
          [0] = 0,
          
          [nil] = 1,
          
          [if#](x0, x1, x2) = x0 + 1
         Strict:
          if#(mark X1, X2, X3) -> if#(X1, X2, X3)
          2 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
         Weak:
          top ok X -> top active X
          1 + 0X >= 2 + 1X
          top mark X -> top proper X
          2 + 1X >= 1 + 0X
          proper from X -> from proper X
          0 + 0X >= 0 + 0X
          proper cons(X1, X2) -> cons(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper first(X1, X2) -> first(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper nil() -> ok nil()
          0 >= 0
          proper s X -> s proper X
          0 + 0X >= 1 + 0X
          proper 0() -> ok 0()
          0 >= 0
          proper add(X1, X2) -> add(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
          0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
          proper false() -> ok false()
          0 >= 0
          proper true() -> ok true()
          0 >= 0
          proper and(X1, X2) -> and(proper X1, proper X2)
          0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
          from ok X -> ok from X
          0 + 0X >= 0 + 0X
          cons(ok X1, ok X2) -> ok cons(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          first(ok X1, ok X2) -> ok first(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          first(mark X1, X2) -> mark first(X1, X2)
          1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
          first(X1, mark X2) -> mark first(X1, X2)
          2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
          s ok X -> ok s X
          1 + 0X >= 0 + 0X
          add(ok X1, ok X2) -> ok add(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          add(mark X1, X2) -> mark add(X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
          if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
          1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
          if(mark X1, X2, X3) -> mark if(X1, X2, X3)
          2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
          and(ok X1, ok X2) -> ok and(X1, X2)
          1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
          and(mark X1, X2) -> mark and(X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
          active from X -> mark cons(X, from s X)
          1 + 0X >= 2 + 0X
          active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
          3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
          active first(0(), X) -> mark nil()
          2 + 1X >= 2
          active first(X1, X2) -> first(active X1, X2)
          2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
          active first(X1, X2) -> first(X1, active X2)
          2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
          active add(s X, Y) -> mark s add(X, Y)
          3 + 1X + 0Y >= 3 + 1X + 0Y
          active add(0(), X) -> mark X
          2 + 0X >= 1 + 1X
          active add(X1, X2) -> add(active X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
          active if(false(), X, Y) -> mark Y
          2 + 0X + 0Y >= 1 + 1Y
          active if(true(), X, Y) -> mark X
          2 + 0X + 0Y >= 1 + 1X
          active if(X1, X2, X3) -> if(active X1, X2, X3)
          2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
          active and(false(), Y) -> mark false()
          2 + 0Y >= 1
          active and(true(), X) -> mark X
          2 + 0X >= 1 + 1X
          active and(X1, X2) -> and(active X1, X2)
          2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
        Qed
    
    SCC (2):
     Strict:
      { and#(mark X1, X2) -> and#(X1, X2),
       and#(ok X1, ok X2) -> and#(X1, X2)}
     Weak:
     {           active and(X1, X2) -> and(active X1, X2),
              active and(true(), X) -> mark X,
             active and(false(), Y) -> mark false(),
              active if(X1, X2, X3) -> if(active X1, X2, X3),
            active if(true(), X, Y) -> mark X,
           active if(false(), X, Y) -> mark Y,
                 active add(X1, X2) -> add(active X1, X2),
                 active add(0(), X) -> mark X,
                 active add(s X, Y) -> mark s add(X, Y),
               active first(X1, X2) -> first(X1, active X2),
               active first(X1, X2) -> first(active X1, X2),
               active first(0(), X) -> mark nil(),
      active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                      active from X -> mark cons(X, from s X),
                   and(mark X1, X2) -> mark and(X1, X2),
                  and(ok X1, ok X2) -> ok and(X1, X2),
                if(mark X1, X2, X3) -> mark if(X1, X2, X3),
            if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                   add(mark X1, X2) -> mark add(X1, X2),
                  add(ok X1, ok X2) -> ok add(X1, X2),
                             s ok X -> ok s X,
                 first(X1, mark X2) -> mark first(X1, X2),
                 first(mark X1, X2) -> mark first(X1, X2),
                first(ok X1, ok X2) -> ok first(X1, X2),
                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                          from ok X -> ok from X,
                 proper and(X1, X2) -> and(proper X1, proper X2),
                      proper true() -> ok true(),
                     proper false() -> ok false(),
              proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                 proper add(X1, X2) -> add(proper X1, proper X2),
                         proper 0() -> ok 0(),
                         proper s X -> s proper X,
                       proper nil() -> ok nil(),
               proper first(X1, X2) -> first(proper X1, proper X2),
                proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper from X -> from proper X,
                         top mark X -> top proper X,
                           top ok X -> top active X}
     POLY:
      Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
      Interpretation:
       [if](x0, x1, x2) = x0 + 1,
       
       [and](x0, x1) = x0 + 1,
       
       [add](x0, x1) = 0,
       
       [first](x0, x1) = x0 + 1,
       
       [cons](x0, x1) = x0 + 1,
       
       [mark](x0) = x0 + 1,
       
       [active](x0) = x0 + 1,
       
       [s](x0) = 0,
       
       [from](x0) = 1,
       
       [proper](x0) = x0,
       
       [ok](x0) = x0 + 1,
       
       [top](x0) = 0,
       
       [true] = 0,
       
       [false] = 1,
       
       [0] = 0,
       
       [nil] = 1,
       
       [and#](x0, x1) = x0
      Strict:
       and#(ok X1, ok X2) -> and#(X1, X2)
       1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
       and#(mark X1, X2) -> and#(X1, X2)
       0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
      Weak:
       top ok X -> top active X
       0 + 0X >= 0 + 0X
       top mark X -> top proper X
       0 + 0X >= 0 + 0X
       proper from X -> from proper X
       1 + 0X >= 1 + 0X
       proper cons(X1, X2) -> cons(proper X1, proper X2)
       1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       proper first(X1, X2) -> first(proper X1, proper X2)
       1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       proper nil() -> ok nil()
       1 >= 2
       proper s X -> s proper X
       0 + 0X >= 0 + 0X
       proper 0() -> ok 0()
       0 >= 1
       proper add(X1, X2) -> add(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
       1 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
       proper false() -> ok false()
       1 >= 2
       proper true() -> ok true()
       0 >= 1
       proper and(X1, X2) -> and(proper X1, proper X2)
       1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
       from ok X -> ok from X
       1 + 0X >= 2 + 0X
       cons(ok X1, ok X2) -> ok cons(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       first(ok X1, ok X2) -> ok first(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       first(mark X1, X2) -> mark first(X1, X2)
       1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       first(X1, mark X2) -> mark first(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       s ok X -> ok s X
       0 + 0X >= 1 + 0X
       add(ok X1, ok X2) -> ok add(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       add(mark X1, X2) -> mark add(X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
       2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
       if(mark X1, X2, X3) -> mark if(X1, X2, X3)
       2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
       and(ok X1, ok X2) -> ok and(X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       and(mark X1, X2) -> mark and(X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       active from X -> mark cons(X, from s X)
       2 + 0X >= 3 + 0X
       active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
       3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
       active first(0(), X) -> mark nil()
       2 + 1X >= 2
       active first(X1, X2) -> first(active X1, X2)
       2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       active first(X1, X2) -> first(X1, active X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       active add(s X, Y) -> mark s add(X, Y)
       1 + 0X + 0Y >= 1 + 0X + 0Y
       active add(0(), X) -> mark X
       1 + 0X >= 1 + 1X
       active add(X1, X2) -> add(active X1, X2)
       1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       active if(false(), X, Y) -> mark Y
       3 + 0X + 0Y >= 1 + 1Y
       active if(true(), X, Y) -> mark X
       2 + 0X + 0Y >= 1 + 1X
       active if(X1, X2, X3) -> if(active X1, X2, X3)
       2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
       active and(false(), Y) -> mark false()
       3 + 0Y >= 2
       active and(true(), X) -> mark X
       2 + 0X >= 1 + 1X
       active and(X1, X2) -> and(active X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     SCCS (1):
      Scc:
       {and#(mark X1, X2) -> and#(X1, X2)}
      
      SCC (1):
       Strict:
        {and#(mark X1, X2) -> and#(X1, X2)}
       Weak:
       {           active and(X1, X2) -> and(active X1, X2),
                active and(true(), X) -> mark X,
               active and(false(), Y) -> mark false(),
                active if(X1, X2, X3) -> if(active X1, X2, X3),
              active if(true(), X, Y) -> mark X,
             active if(false(), X, Y) -> mark Y,
                   active add(X1, X2) -> add(active X1, X2),
                   active add(0(), X) -> mark X,
                   active add(s X, Y) -> mark s add(X, Y),
                 active first(X1, X2) -> first(X1, active X2),
                 active first(X1, X2) -> first(active X1, X2),
                 active first(0(), X) -> mark nil(),
        active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                        active from X -> mark cons(X, from s X),
                     and(mark X1, X2) -> mark and(X1, X2),
                    and(ok X1, ok X2) -> ok and(X1, X2),
                  if(mark X1, X2, X3) -> mark if(X1, X2, X3),
              if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                     add(mark X1, X2) -> mark add(X1, X2),
                    add(ok X1, ok X2) -> ok add(X1, X2),
                               s ok X -> ok s X,
                   first(X1, mark X2) -> mark first(X1, X2),
                   first(mark X1, X2) -> mark first(X1, X2),
                  first(ok X1, ok X2) -> ok first(X1, X2),
                   cons(ok X1, ok X2) -> ok cons(X1, X2),
                            from ok X -> ok from X,
                   proper and(X1, X2) -> and(proper X1, proper X2),
                        proper true() -> ok true(),
                       proper false() -> ok false(),
                proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                   proper add(X1, X2) -> add(proper X1, proper X2),
                           proper 0() -> ok 0(),
                           proper s X -> s proper X,
                         proper nil() -> ok nil(),
                 proper first(X1, X2) -> first(proper X1, proper X2),
                  proper cons(X1, X2) -> cons(proper X1, proper X2),
                        proper from X -> from proper X,
                           top mark X -> top proper X,
                             top ok X -> top active X}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [if](x0, x1, x2) = x0 + 1,
         
         [and](x0, x1) = x0 + 1,
         
         [add](x0, x1) = x0 + 1,
         
         [first](x0, x1) = x0 + 1,
         
         [cons](x0, x1) = x0 + 1,
         
         [mark](x0) = x0 + 1,
         
         [active](x0) = x0 + 1,
         
         [s](x0) = x0 + 1,
         
         [from](x0) = 0,
         
         [proper](x0) = 0,
         
         [ok](x0) = 0,
         
         [top](x0) = x0 + 1,
         
         [true] = 0,
         
         [false] = 0,
         
         [0] = 0,
         
         [nil] = 1,
         
         [and#](x0, x1) = x0 + 1
        Strict:
         and#(mark X1, X2) -> and#(X1, X2)
         2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
        Weak:
         top ok X -> top active X
         1 + 0X >= 2 + 1X
         top mark X -> top proper X
         2 + 1X >= 1 + 0X
         proper from X -> from proper X
         0 + 0X >= 0 + 0X
         proper cons(X1, X2) -> cons(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper first(X1, X2) -> first(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper nil() -> ok nil()
         0 >= 0
         proper s X -> s proper X
         0 + 0X >= 1 + 0X
         proper 0() -> ok 0()
         0 >= 0
         proper add(X1, X2) -> add(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
         0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
         proper false() -> ok false()
         0 >= 0
         proper true() -> ok true()
         0 >= 0
         proper and(X1, X2) -> and(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         from ok X -> ok from X
         0 + 0X >= 0 + 0X
         cons(ok X1, ok X2) -> ok cons(X1, X2)
         1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         first(ok X1, ok X2) -> ok first(X1, X2)
         1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         first(mark X1, X2) -> mark first(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         first(X1, mark X2) -> mark first(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         s ok X -> ok s X
         1 + 0X >= 0 + 0X
         add(ok X1, ok X2) -> ok add(X1, X2)
         1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         add(mark X1, X2) -> mark add(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
         1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
         if(mark X1, X2, X3) -> mark if(X1, X2, X3)
         2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
         and(ok X1, ok X2) -> ok and(X1, X2)
         1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         and(mark X1, X2) -> mark and(X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         active from X -> mark cons(X, from s X)
         1 + 0X >= 2 + 0X
         active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
         3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
         active first(0(), X) -> mark nil()
         2 + 1X >= 2
         active first(X1, X2) -> first(active X1, X2)
         2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
         active first(X1, X2) -> first(X1, active X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         active add(s X, Y) -> mark s add(X, Y)
         3 + 1X + 0Y >= 3 + 1X + 0Y
         active add(0(), X) -> mark X
         2 + 0X >= 1 + 1X
         active add(X1, X2) -> add(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
         active if(false(), X, Y) -> mark Y
         2 + 0X + 0Y >= 1 + 1Y
         active if(true(), X, Y) -> mark X
         2 + 0X + 0Y >= 1 + 1X
         active if(X1, X2, X3) -> if(active X1, X2, X3)
         2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
         active and(false(), Y) -> mark false()
         2 + 0Y >= 1
         active and(true(), X) -> mark X
         2 + 0X >= 1 + 1X
         active and(X1, X2) -> and(active X1, X2)
         2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       Qed
   SCC (1):
    Strict:
     {from# ok X -> from# X}
    Weak:
    {           active and(X1, X2) -> and(active X1, X2),
             active and(true(), X) -> mark X,
            active and(false(), Y) -> mark false(),
             active if(X1, X2, X3) -> if(active X1, X2, X3),
           active if(true(), X, Y) -> mark X,
          active if(false(), X, Y) -> mark Y,
                active add(X1, X2) -> add(active X1, X2),
                active add(0(), X) -> mark X,
                active add(s X, Y) -> mark s add(X, Y),
              active first(X1, X2) -> first(X1, active X2),
              active first(X1, X2) -> first(active X1, X2),
              active first(0(), X) -> mark nil(),
     active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                     active from X -> mark cons(X, from s X),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
               if(mark X1, X2, X3) -> mark if(X1, X2, X3),
           if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                  add(mark X1, X2) -> mark add(X1, X2),
                 add(ok X1, ok X2) -> ok add(X1, X2),
                            s ok X -> ok s X,
                first(X1, mark X2) -> mark first(X1, X2),
                first(mark X1, X2) -> mark first(X1, X2),
               first(ok X1, ok X2) -> ok first(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                         from ok X -> ok from X,
                proper and(X1, X2) -> and(proper X1, proper X2),
                     proper true() -> ok true(),
                    proper false() -> ok false(),
             proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                proper add(X1, X2) -> add(proper X1, proper X2),
                        proper 0() -> ok 0(),
                        proper s X -> s proper X,
                      proper nil() -> ok nil(),
              proper first(X1, X2) -> first(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                     proper from X -> from proper X,
                        top mark X -> top proper X,
                          top ok X -> top active X}
    POLY:
     Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
     Interpretation:
      [if](x0, x1, x2) = x0 + 1,
      
      [and](x0, x1) = x0 + 1,
      
      [add](x0, x1) = x0 + 1,
      
      [first](x0, x1) = x0 + 1,
      
      [cons](x0, x1) = x0 + 1,
      
      [mark](x0) = x0 + 1,
      
      [active](x0) = x0 + 1,
      
      [s](x0) = x0 + 1,
      
      [from](x0) = 0,
      
      [proper](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [top](x0) = x0 + 1,
      
      [true] = 0,
      
      [false] = 1,
      
      [0] = 0,
      
      [nil] = 1,
      
      [from#](x0) = x0 + 1
     Strict:
      from# ok X -> from# X
      2 + 1X >= 1 + 1X
     Weak:
      top ok X -> top active X
      2 + 1X >= 2 + 1X
      top mark X -> top proper X
      2 + 1X >= 1 + 0X
      proper from X -> from proper X
      0 + 0X >= 0 + 0X
      proper cons(X1, X2) -> cons(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper first(X1, X2) -> first(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper nil() -> ok nil()
      0 >= 2
      proper s X -> s proper X
      0 + 0X >= 1 + 0X
      proper 0() -> ok 0()
      0 >= 1
      proper add(X1, X2) -> add(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
      0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
      proper false() -> ok false()
      0 >= 2
      proper true() -> ok true()
      0 >= 1
      proper and(X1, X2) -> and(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      from ok X -> ok from X
      0 + 0X >= 1 + 0X
      cons(ok X1, ok X2) -> ok cons(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      first(ok X1, ok X2) -> ok first(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      first(mark X1, X2) -> mark first(X1, X2)
      1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      first(X1, mark X2) -> mark first(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      s ok X -> ok s X
      2 + 1X >= 2 + 1X
      add(ok X1, ok X2) -> ok add(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      add(mark X1, X2) -> mark add(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
      2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
      if(mark X1, X2, X3) -> mark if(X1, X2, X3)
      2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
      and(ok X1, ok X2) -> ok and(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      and(mark X1, X2) -> mark and(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      active from X -> mark cons(X, from s X)
      1 + 0X >= 2 + 0X
      active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
      3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
      active first(0(), X) -> mark nil()
      2 + 1X >= 2
      active first(X1, X2) -> first(active X1, X2)
      2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
      active first(X1, X2) -> first(X1, active X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      active add(s X, Y) -> mark s add(X, Y)
      3 + 1X + 0Y >= 3 + 1X + 0Y
      active add(0(), X) -> mark X
      2 + 0X >= 1 + 1X
      active add(X1, X2) -> add(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      active if(false(), X, Y) -> mark Y
      3 + 0X + 0Y >= 1 + 1Y
      active if(true(), X, Y) -> mark X
      2 + 0X + 0Y >= 1 + 1X
      active if(X1, X2, X3) -> if(active X1, X2, X3)
      2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
      active and(false(), Y) -> mark false()
      3 + 0Y >= 2
      active and(true(), X) -> mark X
      2 + 0X >= 1 + 1X
      active and(X1, X2) -> and(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    Qed
   
   SCC (1):
    Strict:
     {s# ok X -> s# X}
    Weak:
    {           active and(X1, X2) -> and(active X1, X2),
             active and(true(), X) -> mark X,
            active and(false(), Y) -> mark false(),
             active if(X1, X2, X3) -> if(active X1, X2, X3),
           active if(true(), X, Y) -> mark X,
          active if(false(), X, Y) -> mark Y,
                active add(X1, X2) -> add(active X1, X2),
                active add(0(), X) -> mark X,
                active add(s X, Y) -> mark s add(X, Y),
              active first(X1, X2) -> first(X1, active X2),
              active first(X1, X2) -> first(active X1, X2),
              active first(0(), X) -> mark nil(),
     active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                     active from X -> mark cons(X, from s X),
                  and(mark X1, X2) -> mark and(X1, X2),
                 and(ok X1, ok X2) -> ok and(X1, X2),
               if(mark X1, X2, X3) -> mark if(X1, X2, X3),
           if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                  add(mark X1, X2) -> mark add(X1, X2),
                 add(ok X1, ok X2) -> ok add(X1, X2),
                            s ok X -> ok s X,
                first(X1, mark X2) -> mark first(X1, X2),
                first(mark X1, X2) -> mark first(X1, X2),
               first(ok X1, ok X2) -> ok first(X1, X2),
                cons(ok X1, ok X2) -> ok cons(X1, X2),
                         from ok X -> ok from X,
                proper and(X1, X2) -> and(proper X1, proper X2),
                     proper true() -> ok true(),
                    proper false() -> ok false(),
             proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                proper add(X1, X2) -> add(proper X1, proper X2),
                        proper 0() -> ok 0(),
                        proper s X -> s proper X,
                      proper nil() -> ok nil(),
              proper first(X1, X2) -> first(proper X1, proper X2),
               proper cons(X1, X2) -> cons(proper X1, proper X2),
                     proper from X -> from proper X,
                        top mark X -> top proper X,
                          top ok X -> top active X}
    POLY:
     Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
     Interpretation:
      [if](x0, x1, x2) = x0 + 1,
      
      [and](x0, x1) = x0 + 1,
      
      [add](x0, x1) = x0 + 1,
      
      [first](x0, x1) = x0 + 1,
      
      [cons](x0, x1) = x0 + 1,
      
      [mark](x0) = x0 + 1,
      
      [active](x0) = x0 + 1,
      
      [s](x0) = x0 + 1,
      
      [from](x0) = 0,
      
      [proper](x0) = 0,
      
      [ok](x0) = x0 + 1,
      
      [top](x0) = x0 + 1,
      
      [true] = 0,
      
      [false] = 1,
      
      [0] = 0,
      
      [nil] = 1,
      
      [s#](x0) = x0 + 1
     Strict:
      s# ok X -> s# X
      2 + 1X >= 1 + 1X
     Weak:
      top ok X -> top active X
      2 + 1X >= 2 + 1X
      top mark X -> top proper X
      2 + 1X >= 1 + 0X
      proper from X -> from proper X
      0 + 0X >= 0 + 0X
      proper cons(X1, X2) -> cons(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper first(X1, X2) -> first(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper nil() -> ok nil()
      0 >= 2
      proper s X -> s proper X
      0 + 0X >= 1 + 0X
      proper 0() -> ok 0()
      0 >= 1
      proper add(X1, X2) -> add(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
      0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
      proper false() -> ok false()
      0 >= 2
      proper true() -> ok true()
      0 >= 1
      proper and(X1, X2) -> and(proper X1, proper X2)
      0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
      from ok X -> ok from X
      0 + 0X >= 1 + 0X
      cons(ok X1, ok X2) -> ok cons(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      first(ok X1, ok X2) -> ok first(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      first(mark X1, X2) -> mark first(X1, X2)
      1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      first(X1, mark X2) -> mark first(X1, X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      s ok X -> ok s X
      2 + 1X >= 2 + 1X
      add(ok X1, ok X2) -> ok add(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      add(mark X1, X2) -> mark add(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
      2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
      if(mark X1, X2, X3) -> mark if(X1, X2, X3)
      2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
      and(ok X1, ok X2) -> ok and(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      and(mark X1, X2) -> mark and(X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      active from X -> mark cons(X, from s X)
      1 + 0X >= 2 + 0X
      active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
      3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
      active first(0(), X) -> mark nil()
      2 + 1X >= 2
      active first(X1, X2) -> first(active X1, X2)
      2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
      active first(X1, X2) -> first(X1, active X2)
      2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
      active add(s X, Y) -> mark s add(X, Y)
      3 + 1X + 0Y >= 3 + 1X + 0Y
      active add(0(), X) -> mark X
      2 + 0X >= 1 + 1X
      active add(X1, X2) -> add(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
      active if(false(), X, Y) -> mark Y
      3 + 0X + 0Y >= 1 + 1Y
      active if(true(), X, Y) -> mark X
      2 + 0X + 0Y >= 1 + 1X
      active if(X1, X2, X3) -> if(active X1, X2, X3)
      2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
      active and(false(), Y) -> mark false()
      3 + 0Y >= 2
      active and(true(), X) -> mark X
      2 + 0X >= 1 + 1X
      active and(X1, X2) -> and(active X1, X2)
      2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
    Qed
  
  SCC (2):
   Strict:
    { add#(mark X1, X2) -> add#(X1, X2),
     add#(ok X1, ok X2) -> add#(X1, X2)}
   Weak:
   {           active and(X1, X2) -> and(active X1, X2),
            active and(true(), X) -> mark X,
           active and(false(), Y) -> mark false(),
            active if(X1, X2, X3) -> if(active X1, X2, X3),
          active if(true(), X, Y) -> mark X,
         active if(false(), X, Y) -> mark Y,
               active add(X1, X2) -> add(active X1, X2),
               active add(0(), X) -> mark X,
               active add(s X, Y) -> mark s add(X, Y),
             active first(X1, X2) -> first(X1, active X2),
             active first(X1, X2) -> first(active X1, X2),
             active first(0(), X) -> mark nil(),
    active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                    active from X -> mark cons(X, from s X),
                 and(mark X1, X2) -> mark and(X1, X2),
                and(ok X1, ok X2) -> ok and(X1, X2),
              if(mark X1, X2, X3) -> mark if(X1, X2, X3),
          if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                 add(mark X1, X2) -> mark add(X1, X2),
                add(ok X1, ok X2) -> ok add(X1, X2),
                           s ok X -> ok s X,
               first(X1, mark X2) -> mark first(X1, X2),
               first(mark X1, X2) -> mark first(X1, X2),
              first(ok X1, ok X2) -> ok first(X1, X2),
               cons(ok X1, ok X2) -> ok cons(X1, X2),
                        from ok X -> ok from X,
               proper and(X1, X2) -> and(proper X1, proper X2),
                    proper true() -> ok true(),
                   proper false() -> ok false(),
            proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
               proper add(X1, X2) -> add(proper X1, proper X2),
                       proper 0() -> ok 0(),
                       proper s X -> s proper X,
                     proper nil() -> ok nil(),
             proper first(X1, X2) -> first(proper X1, proper X2),
              proper cons(X1, X2) -> cons(proper X1, proper X2),
                    proper from X -> from proper X,
                       top mark X -> top proper X,
                         top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [if](x0, x1, x2) = x0 + 1,
     
     [and](x0, x1) = x0 + 1,
     
     [add](x0, x1) = 0,
     
     [first](x0, x1) = x0 + 1,
     
     [cons](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [s](x0) = 0,
     
     [from](x0) = 1,
     
     [proper](x0) = x0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = 0,
     
     [true] = 0,
     
     [false] = 1,
     
     [0] = 0,
     
     [nil] = 1,
     
     [add#](x0, x1) = x0
    Strict:
     add#(ok X1, ok X2) -> add#(X1, X2)
     1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
     add#(mark X1, X2) -> add#(X1, X2)
     0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     0 + 0X >= 0 + 0X
     top mark X -> top proper X
     0 + 0X >= 0 + 0X
     proper from X -> from proper X
     1 + 0X >= 1 + 0X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     proper first(X1, X2) -> first(proper X1, proper X2)
     1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     proper nil() -> ok nil()
     1 >= 2
     proper s X -> s proper X
     0 + 0X >= 0 + 0X
     proper 0() -> ok 0()
     0 >= 1
     proper add(X1, X2) -> add(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
     1 + 1X1 + 0X2 + 0X3 >= 1 + 1X1 + 0X2 + 0X3
     proper false() -> ok false()
     1 >= 2
     proper true() -> ok true()
     0 >= 1
     proper and(X1, X2) -> and(proper X1, proper X2)
     1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
     from ok X -> ok from X
     1 + 0X >= 2 + 0X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     first(ok X1, ok X2) -> ok first(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     first(mark X1, X2) -> mark first(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     first(X1, mark X2) -> mark first(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     s ok X -> ok s X
     0 + 0X >= 1 + 0X
     add(ok X1, ok X2) -> ok add(X1, X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     add(mark X1, X2) -> mark add(X1, X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
     2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
     if(mark X1, X2, X3) -> mark if(X1, X2, X3)
     2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
     and(ok X1, ok X2) -> ok and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     and(mark X1, X2) -> mark and(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     active from X -> mark cons(X, from s X)
     2 + 0X >= 3 + 0X
     active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
     3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
     active first(0(), X) -> mark nil()
     2 + 1X >= 2
     active first(X1, X2) -> first(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active first(X1, X2) -> first(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active add(s X, Y) -> mark s add(X, Y)
     1 + 0X + 0Y >= 1 + 0X + 0Y
     active add(0(), X) -> mark X
     1 + 0X >= 1 + 1X
     active add(X1, X2) -> add(active X1, X2)
     1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     active if(false(), X, Y) -> mark Y
     3 + 0X + 0Y >= 1 + 1Y
     active if(true(), X, Y) -> mark X
     2 + 0X + 0Y >= 1 + 1X
     active if(X1, X2, X3) -> if(active X1, X2, X3)
     2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
     active and(false(), Y) -> mark false()
     3 + 0Y >= 2
     active and(true(), X) -> mark X
     2 + 0X >= 1 + 1X
     active and(X1, X2) -> and(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   SCCS (1):
    Scc:
     {add#(mark X1, X2) -> add#(X1, X2)}
    
    SCC (1):
     Strict:
      {add#(mark X1, X2) -> add#(X1, X2)}
     Weak:
     {           active and(X1, X2) -> and(active X1, X2),
              active and(true(), X) -> mark X,
             active and(false(), Y) -> mark false(),
              active if(X1, X2, X3) -> if(active X1, X2, X3),
            active if(true(), X, Y) -> mark X,
           active if(false(), X, Y) -> mark Y,
                 active add(X1, X2) -> add(active X1, X2),
                 active add(0(), X) -> mark X,
                 active add(s X, Y) -> mark s add(X, Y),
               active first(X1, X2) -> first(X1, active X2),
               active first(X1, X2) -> first(active X1, X2),
               active first(0(), X) -> mark nil(),
      active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z)),
                      active from X -> mark cons(X, from s X),
                   and(mark X1, X2) -> mark and(X1, X2),
                  and(ok X1, ok X2) -> ok and(X1, X2),
                if(mark X1, X2, X3) -> mark if(X1, X2, X3),
            if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3),
                   add(mark X1, X2) -> mark add(X1, X2),
                  add(ok X1, ok X2) -> ok add(X1, X2),
                             s ok X -> ok s X,
                 first(X1, mark X2) -> mark first(X1, X2),
                 first(mark X1, X2) -> mark first(X1, X2),
                first(ok X1, ok X2) -> ok first(X1, X2),
                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                          from ok X -> ok from X,
                 proper and(X1, X2) -> and(proper X1, proper X2),
                      proper true() -> ok true(),
                     proper false() -> ok false(),
              proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3),
                 proper add(X1, X2) -> add(proper X1, proper X2),
                         proper 0() -> ok 0(),
                         proper s X -> s proper X,
                       proper nil() -> ok nil(),
               proper first(X1, X2) -> first(proper X1, proper X2),
                proper cons(X1, X2) -> cons(proper X1, proper X2),
                      proper from X -> from proper X,
                         top mark X -> top proper X,
                           top ok X -> top active X}
     POLY:
      Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
      Interpretation:
       [if](x0, x1, x2) = x0 + 1,
       
       [and](x0, x1) = x0 + 1,
       
       [add](x0, x1) = x0 + 1,
       
       [first](x0, x1) = x0 + 1,
       
       [cons](x0, x1) = x0 + 1,
       
       [mark](x0) = x0 + 1,
       
       [active](x0) = x0 + 1,
       
       [s](x0) = x0 + 1,
       
       [from](x0) = 0,
       
       [proper](x0) = 0,
       
       [ok](x0) = 0,
       
       [top](x0) = x0 + 1,
       
       [true] = 0,
       
       [false] = 0,
       
       [0] = 0,
       
       [nil] = 1,
       
       [add#](x0, x1) = x0 + 1
      Strict:
       add#(mark X1, X2) -> add#(X1, X2)
       2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
      Weak:
       top ok X -> top active X
       1 + 0X >= 2 + 1X
       top mark X -> top proper X
       2 + 1X >= 1 + 0X
       proper from X -> from proper X
       0 + 0X >= 0 + 0X
       proper cons(X1, X2) -> cons(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper first(X1, X2) -> first(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper nil() -> ok nil()
       0 >= 0
       proper s X -> s proper X
       0 + 0X >= 1 + 0X
       proper 0() -> ok 0()
       0 >= 0
       proper add(X1, X2) -> add(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper if(X1, X2, X3) -> if(proper X1, proper X2, proper X3)
       0 + 0X1 + 0X2 + 0X3 >= 1 + 0X1 + 0X2 + 0X3
       proper false() -> ok false()
       0 >= 0
       proper true() -> ok true()
       0 >= 0
       proper and(X1, X2) -> and(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       from ok X -> ok from X
       0 + 0X >= 0 + 0X
       cons(ok X1, ok X2) -> ok cons(X1, X2)
       1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       first(ok X1, ok X2) -> ok first(X1, X2)
       1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       first(mark X1, X2) -> mark first(X1, X2)
       1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       first(X1, mark X2) -> mark first(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       s ok X -> ok s X
       1 + 0X >= 0 + 0X
       add(ok X1, ok X2) -> ok add(X1, X2)
       1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       add(mark X1, X2) -> mark add(X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       if(ok X1, ok X2, ok X3) -> ok if(X1, X2, X3)
       1 + 0X1 + 0X2 + 0X3 >= 0 + 0X1 + 0X2 + 0X3
       if(mark X1, X2, X3) -> mark if(X1, X2, X3)
       2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
       and(ok X1, ok X2) -> ok and(X1, X2)
       1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       and(mark X1, X2) -> mark and(X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       active from X -> mark cons(X, from s X)
       1 + 0X >= 2 + 0X
       active first(s X, cons(Y, Z)) -> mark cons(Y, first(X, Z))
       3 + 0X + 0Y + 1Z >= 3 + 0X + 0Y + 1Z
       active first(0(), X) -> mark nil()
       2 + 1X >= 2
       active first(X1, X2) -> first(active X1, X2)
       2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       active first(X1, X2) -> first(X1, active X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       active add(s X, Y) -> mark s add(X, Y)
       3 + 1X + 0Y >= 3 + 1X + 0Y
       active add(0(), X) -> mark X
       2 + 0X >= 1 + 1X
       active add(X1, X2) -> add(active X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
       active if(false(), X, Y) -> mark Y
       2 + 0X + 0Y >= 1 + 1Y
       active if(true(), X, Y) -> mark X
       2 + 0X + 0Y >= 1 + 1X
       active if(X1, X2, X3) -> if(active X1, X2, X3)
       2 + 1X1 + 0X2 + 0X3 >= 2 + 1X1 + 0X2 + 0X3
       active and(false(), Y) -> mark false()
       2 + 0Y >= 1
       active and(true(), X) -> mark X
       2 + 0X >= 1 + 1X
       active and(X1, X2) -> and(active X1, X2)
       2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     Qed