MAYBE
Time: 2.036003
TRS:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 DP:
  DP:
   {                      cons#(mark X1, X2) -> cons#(X1, X2),
                         cons#(ok X1, ok X2) -> cons#(X1, X2),
                                from# mark X -> from# X,
                                  from# ok X -> from# X,
                                   s# mark X -> s# X,
                                     s# ok X -> s# X,
                        active# cons(X1, X2) -> cons#(active X1, X2),
                        active# cons(X1, X2) -> active# X1,
                              active# from X -> cons#(X, from s X),
                              active# from X -> from# s X,
                              active# from X -> from# active X,
                              active# from X -> s# X,
                              active# from X -> active# X,
                                 active# s X -> s# active X,
                                 active# s X -> active# X,
                         active# sel(X1, X2) -> active# X1,
                         active# sel(X1, X2) -> active# X2,
                         active# sel(X1, X2) -> sel#(X1, active X2),
                         active# sel(X1, X2) -> sel#(active X1, X2),
               active# sel(s N, cons(X, XS)) -> sel#(N, XS),
                       active# minus(X1, X2) -> active# X1,
                       active# minus(X1, X2) -> active# X2,
                       active# minus(X1, X2) -> minus#(X1, active X2),
                       active# minus(X1, X2) -> minus#(active X1, X2),
                     active# minus(s X, s Y) -> minus#(X, Y),
                        active# quot(X1, X2) -> active# X1,
                        active# quot(X1, X2) -> active# X2,
                        active# quot(X1, X2) -> quot#(X1, active X2),
                        active# quot(X1, X2) -> quot#(active X1, X2),
                      active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y),
                      active# quot(s X, s Y) -> minus#(X, Y),
                      active# quot(s X, s Y) -> quot#(minus(X, Y), s Y),
                      active# zWquot(X1, X2) -> active# X1,
                      active# zWquot(X1, X2) -> active# X2,
                      active# zWquot(X1, X2) -> zWquot#(X1, active X2),
                      active# zWquot(X1, X2) -> zWquot#(active X1, X2),
    active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)),
    active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y),
    active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS),
                           sel#(X1, mark X2) -> sel#(X1, X2),
                           sel#(mark X1, X2) -> sel#(X1, X2),
                          sel#(ok X1, ok X2) -> sel#(X1, X2),
                         minus#(X1, mark X2) -> minus#(X1, X2),
                         minus#(mark X1, X2) -> minus#(X1, X2),
                        minus#(ok X1, ok X2) -> minus#(X1, X2),
                          quot#(X1, mark X2) -> quot#(X1, X2),
                          quot#(mark X1, X2) -> quot#(X1, X2),
                         quot#(ok X1, ok X2) -> quot#(X1, X2),
                        zWquot#(X1, mark X2) -> zWquot#(X1, X2),
                        zWquot#(mark X1, X2) -> zWquot#(X1, X2),
                       zWquot#(ok X1, ok X2) -> zWquot#(X1, 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,
                                 proper# s X -> s# proper X,
                                 proper# s X -> proper# X,
                         proper# sel(X1, X2) -> sel#(proper X1, proper X2),
                         proper# sel(X1, X2) -> proper# X1,
                         proper# sel(X1, X2) -> proper# X2,
                       proper# minus(X1, X2) -> minus#(proper X1, proper X2),
                       proper# minus(X1, X2) -> proper# X1,
                       proper# minus(X1, X2) -> proper# X2,
                        proper# quot(X1, X2) -> quot#(proper X1, proper X2),
                        proper# quot(X1, X2) -> proper# X1,
                        proper# quot(X1, X2) -> proper# X2,
                      proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2),
                      proper# zWquot(X1, X2) -> proper# X1,
                      proper# zWquot(X1, X2) -> proper# X2,
                                 top# mark X -> proper# X,
                                 top# mark X -> top# proper X,
                                   top# ok X -> active# X,
                                   top# ok X -> top# active X}
  TRS:
  {                      cons(mark X1, X2) -> mark cons(X1, X2),
                        cons(ok X1, ok X2) -> ok cons(X1, X2),
                               from mark X -> mark from X,
                                 from ok X -> ok from X,
                                  s mark X -> mark s X,
                                    s ok X -> ok s X,
                       active cons(X1, X2) -> cons(active X1, X2),
                             active from X -> mark cons(X, from s X),
                             active from X -> from active X,
                                active s X -> s active X,
                        active sel(X1, X2) -> sel(X1, active X2),
                        active sel(X1, X2) -> sel(active X1, X2),
              active sel(s N, cons(X, XS)) -> mark sel(N, XS),
              active sel(0(), cons(X, XS)) -> mark X,
                      active minus(X, 0()) -> mark 0(),
                      active minus(X1, X2) -> minus(X1, active X2),
                      active minus(X1, X2) -> minus(active X1, X2),
                    active minus(s X, s Y) -> mark minus(X, Y),
                       active quot(X1, X2) -> quot(X1, active X2),
                       active quot(X1, X2) -> quot(active X1, X2),
                     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                     active quot(0(), s Y) -> mark 0(),
                  active zWquot(XS, nil()) -> mark nil(),
                     active zWquot(X1, X2) -> zWquot(X1, active X2),
                     active zWquot(X1, X2) -> zWquot(active X1, X2),
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                  active zWquot(nil(), XS) -> mark nil(),
                          sel(X1, mark X2) -> mark sel(X1, X2),
                          sel(mark X1, X2) -> mark sel(X1, X2),
                         sel(ok X1, ok X2) -> ok sel(X1, X2),
                        minus(X1, mark X2) -> mark minus(X1, X2),
                        minus(mark X1, X2) -> mark minus(X1, X2),
                       minus(ok X1, ok X2) -> ok minus(X1, X2),
                         quot(X1, mark X2) -> mark quot(X1, X2),
                         quot(mark X1, X2) -> mark quot(X1, X2),
                        quot(ok X1, ok X2) -> ok quot(X1, X2),
                       zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                       zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                      zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                       proper cons(X1, X2) -> cons(proper X1, proper X2),
                             proper from X -> from proper X,
                                proper s X -> s proper X,
                        proper sel(X1, X2) -> sel(proper X1, proper X2),
                                proper 0() -> ok 0(),
                      proper minus(X1, X2) -> minus(proper X1, proper X2),
                       proper quot(X1, X2) -> quot(proper X1, proper X2),
                              proper nil() -> ok nil(),
                     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                top mark X -> top proper X,
                                  top ok X -> top active X}
  UR:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)}
   EDG:
    {
     (active# from X -> from# s X, from# ok X -> from# X)
     (active# from X -> from# s X, from# mark X -> from# X)
     (active# s X -> s# active X, s# ok X -> s# X)
     (active# s X -> s# active X, s# mark X -> s# X)
     (proper# s X -> s# proper X, s# ok X -> s# X)
     (proper# s X -> s# proper X, s# mark X -> s# X)
     (top# ok X -> top# active X, top# ok X -> top# active X)
     (top# ok X -> top# active X, top# ok X -> active# X)
     (top# ok X -> top# active X, top# mark X -> top# proper X)
     (top# ok X -> top# active X, top# mark X -> proper# X)
     (active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)), cons#(mark X1, X2) -> cons#(X1, X2))
     (active# minus(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# minus(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# minus(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# minus(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# minus(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# minus(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X2, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# minus(X1, X2) -> active# X2, active# quot(s X, s Y) -> minus#(X, Y))
     (active# minus(X1, X2) -> active# X2, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# minus(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# minus(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# minus(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X2, active# minus(s X, s Y) -> minus#(X, Y))
     (active# minus(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# minus(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# minus(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X2, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# minus(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# minus(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# minus(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X2, active# s X -> active# X)
     (active# minus(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# minus(X1, X2) -> active# X2, active# from X -> active# X)
     (active# minus(X1, X2) -> active# X2, active# from X -> s# X)
     (active# minus(X1, X2) -> active# X2, active# from X -> from# active X)
     (active# minus(X1, X2) -> active# X2, active# from X -> from# s X)
     (active# minus(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
     (active# minus(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X2, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# zWquot(X1, X2) -> active# X2, active# quot(s X, s Y) -> minus#(X, Y))
     (active# zWquot(X1, X2) -> active# X2, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# zWquot(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X2, active# minus(s X, s Y) -> minus#(X, Y))
     (active# zWquot(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X2, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# zWquot(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X2, active# s X -> active# X)
     (active# zWquot(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# zWquot(X1, X2) -> active# X2, active# from X -> active# X)
     (active# zWquot(X1, X2) -> active# X2, active# from X -> s# X)
     (active# zWquot(X1, X2) -> active# X2, active# from X -> from# active X)
     (active# zWquot(X1, X2) -> active# X2, active# from X -> from# s X)
     (active# zWquot(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
     (active# zWquot(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (proper# sel(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# sel(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X2, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X2, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# quot(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# quot(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# quot(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# quot(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (active# cons(X1, X2) -> cons#(active X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (active# cons(X1, X2) -> cons#(active X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (active# minus(X1, X2) -> minus#(active X1, X2), minus#(ok X1, ok X2) -> minus#(X1, X2))
     (active# minus(X1, X2) -> minus#(active X1, X2), minus#(mark X1, X2) -> minus#(X1, X2))
     (active# zWquot(X1, X2) -> zWquot#(active X1, X2), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (active# zWquot(X1, X2) -> zWquot#(active X1, X2), zWquot#(mark X1, X2) -> zWquot#(X1, X2))
     (active# sel(X1, X2) -> sel#(X1, active X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (active# sel(X1, X2) -> sel#(X1, active X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (active# quot(X1, X2) -> quot#(X1, active X2), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (active# quot(X1, X2) -> quot#(X1, active X2), quot#(X1, mark X2) -> quot#(X1, X2))
     (active# zWquot(X1, X2) -> zWquot#(X1, active X2), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (active# zWquot(X1, X2) -> zWquot#(X1, active X2), zWquot#(X1, mark X2) -> zWquot#(X1, X2))
     (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (proper# sel(X1, X2) -> sel#(proper X1, proper X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (proper# quot(X1, X2) -> quot#(proper X1, proper X2), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (proper# quot(X1, X2) -> quot#(proper X1, proper X2), quot#(mark X1, X2) -> quot#(X1, X2))
     (proper# quot(X1, X2) -> quot#(proper X1, proper X2), quot#(X1, mark X2) -> quot#(X1, X2))
     (cons#(mark X1, X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (cons#(mark X1, X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (sel#(X1, mark X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (sel#(X1, mark X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (sel#(X1, mark X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (sel#(ok X1, ok X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (minus#(mark X1, X2) -> minus#(X1, X2), minus#(ok X1, ok X2) -> minus#(X1, X2))
     (minus#(mark X1, X2) -> minus#(X1, X2), minus#(mark X1, X2) -> minus#(X1, X2))
     (minus#(mark X1, X2) -> minus#(X1, X2), minus#(X1, mark X2) -> minus#(X1, X2))
     (quot#(X1, mark X2) -> quot#(X1, X2), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (quot#(X1, mark X2) -> quot#(X1, X2), quot#(mark X1, X2) -> quot#(X1, X2))
     (quot#(X1, mark X2) -> quot#(X1, X2), quot#(X1, mark X2) -> quot#(X1, X2))
     (quot#(ok X1, ok X2) -> quot#(X1, X2), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (quot#(ok X1, ok X2) -> quot#(X1, X2), quot#(mark X1, X2) -> quot#(X1, X2))
     (quot#(ok X1, ok X2) -> quot#(X1, X2), quot#(X1, mark X2) -> quot#(X1, X2))
     (zWquot#(mark X1, X2) -> zWquot#(X1, X2), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (zWquot#(mark X1, X2) -> zWquot#(X1, X2), zWquot#(mark X1, X2) -> zWquot#(X1, X2))
     (zWquot#(mark X1, X2) -> zWquot#(X1, X2), zWquot#(X1, mark X2) -> zWquot#(X1, X2))
     (from# mark X -> from# X, from# ok X -> from# X)
     (from# mark X -> from# X, from# mark X -> from# X)
     (s# mark X -> s# X, s# ok X -> s# X)
     (s# mark X -> s# X, s# mark X -> s# X)
     (active# s X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# s X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# s X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# s X -> active# X, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# s X -> active# X, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# s X -> active# X, active# zWquot(X1, X2) -> active# X2)
     (active# s X -> active# X, active# zWquot(X1, X2) -> active# X1)
     (active# s X -> active# X, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# s X -> active# X, active# quot(s X, s Y) -> minus#(X, Y))
     (active# s X -> active# X, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# s X -> active# X, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# s X -> active# X, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# s X -> active# X, active# quot(X1, X2) -> active# X2)
     (active# s X -> active# X, active# quot(X1, X2) -> active# X1)
     (active# s X -> active# X, active# minus(s X, s Y) -> minus#(X, Y))
     (active# s X -> active# X, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# s X -> active# X, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# s X -> active# X, active# minus(X1, X2) -> active# X2)
     (active# s X -> active# X, active# minus(X1, X2) -> active# X1)
     (active# s X -> active# X, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# s X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# s X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# s X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# s X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# s X -> active# X, active# s X -> active# X)
     (active# s X -> active# X, active# s X -> s# active X)
     (active# s X -> active# X, active# from X -> active# X)
     (active# s X -> active# X, active# from X -> s# X)
     (active# s X -> active# X, active# from X -> from# active X)
     (active# s X -> active# X, active# from X -> from# s X)
     (active# s X -> active# X, active# from X -> cons#(X, from s X))
     (active# s X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# s X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (proper# s X -> proper# X, proper# zWquot(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# zWquot(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# quot(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# quot(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# minus(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# minus(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# s X -> proper# X, proper# s X -> proper# X)
     (proper# s X -> proper# X, proper# s X -> s# proper X)
     (proper# s X -> proper# X, proper# from X -> proper# X)
     (proper# s X -> proper# X, proper# from X -> from# proper X)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# s X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (top# ok X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (top# ok X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (top# ok X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (top# ok X -> active# X, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (top# ok X -> active# X, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (top# ok X -> active# X, active# zWquot(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# zWquot(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (top# ok X -> active# X, active# quot(s X, s Y) -> minus#(X, Y))
     (top# ok X -> active# X, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (top# ok X -> active# X, active# quot(X1, X2) -> quot#(active X1, X2))
     (top# ok X -> active# X, active# quot(X1, X2) -> quot#(X1, active X2))
     (top# ok X -> active# X, active# quot(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# quot(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# minus(s X, s Y) -> minus#(X, Y))
     (top# ok X -> active# X, active# minus(X1, X2) -> minus#(active X1, X2))
     (top# ok X -> active# X, active# minus(X1, X2) -> minus#(X1, active X2))
     (top# ok X -> active# X, active# minus(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# minus(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (top# ok X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (top# ok X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (top# ok X -> active# X, active# sel(X1, X2) -> active# X2)
     (top# ok X -> active# X, active# sel(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# s X -> active# X)
     (top# ok X -> active# X, active# s X -> s# active X)
     (top# ok X -> active# X, active# from X -> active# X)
     (top# ok X -> active# X, active# from X -> s# X)
     (top# ok X -> active# X, active# from X -> from# active X)
     (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# cons(X1, X2) -> active# X1)
     (top# ok X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# sel(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# sel(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# sel(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# sel(X1, X2) -> active# X1, active# quot(s X, s Y) -> minus#(X, Y))
     (active# sel(X1, X2) -> active# X1, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# sel(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# minus(s X, s Y) -> minus#(X, Y))
     (active# sel(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# s X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# sel(X1, X2) -> active# X1, active# from X -> active# X)
     (active# sel(X1, X2) -> active# X1, active# from X -> s# X)
     (active# sel(X1, X2) -> active# X1, active# from X -> from# active X)
     (active# sel(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# sel(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# quot(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# quot(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# quot(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# quot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# quot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# quot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X1, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# quot(X1, X2) -> active# X1, active# quot(s X, s Y) -> minus#(X, Y))
     (active# quot(X1, X2) -> active# X1, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# quot(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# quot(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# quot(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X1, active# minus(s X, s Y) -> minus#(X, Y))
     (active# quot(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# quot(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# quot(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X1, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# quot(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# quot(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# quot(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X1, active# s X -> active# X)
     (active# quot(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# quot(X1, X2) -> active# X1, active# from X -> active# X)
     (active# quot(X1, X2) -> active# X1, active# from X -> s# X)
     (active# quot(X1, X2) -> active# X1, active# from X -> from# active X)
     (active# quot(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# quot(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# quot(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (proper# cons(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(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# 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# minus(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X1, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X1, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# minus(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# minus(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# minus(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# minus(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X1, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X1, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# zWquot(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# zWquot(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# zWquot(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# zWquot(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y), s# ok X -> s# X)
     (active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y), s# mark X -> s# X)
     (active# sel(s N, cons(X, XS)) -> sel#(N, XS), sel#(X1, mark X2) -> sel#(X1, X2))
     (proper# quot(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# quot(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# quot(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# quot(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# quot(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X1, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X1, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X2)
     (proper# quot(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# quot(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X1)
     (proper# quot(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# cons(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# from X -> from# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# from X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# s X -> s# proper X)
     (proper# sel(X1, X2) -> proper# X1, proper# s X -> proper# X)
     (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# sel(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# minus(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# quot(X1, X2) -> proper# X2)
     (proper# sel(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# sel(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X1)
     (proper# sel(X1, X2) -> proper# X1, proper# zWquot(X1, X2) -> proper# X2)
     (active# zWquot(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# zWquot(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# zWquot(X1, X2) -> active# X1, active# from X -> from# active X)
     (active# zWquot(X1, X2) -> active# X1, active# from X -> s# X)
     (active# zWquot(X1, X2) -> active# X1, active# from X -> active# X)
     (active# zWquot(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# zWquot(X1, X2) -> active# X1, active# s X -> active# X)
     (active# zWquot(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X1, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# zWquot(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X1, active# minus(s X, s Y) -> minus#(X, Y))
     (active# zWquot(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X1, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# zWquot(X1, X2) -> active# X1, active# quot(s X, s Y) -> minus#(X, Y))
     (active# zWquot(X1, X2) -> active# X1, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X1)
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X2)
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# zWquot(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# minus(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# minus(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# minus(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# minus(X1, X2) -> active# X1, active# from X -> from# active X)
     (active# minus(X1, X2) -> active# X1, active# from X -> s# X)
     (active# minus(X1, X2) -> active# X1, active# from X -> active# X)
     (active# minus(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# minus(X1, X2) -> active# X1, active# s X -> active# X)
     (active# minus(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# minus(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# minus(X1, X2) -> active# X1, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# minus(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# minus(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# minus(X1, X2) -> active# X1, active# minus(s X, s Y) -> minus#(X, Y))
     (active# minus(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# minus(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# minus(X1, X2) -> active# X1, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# minus(X1, X2) -> active# X1, active# quot(s X, s Y) -> minus#(X, Y))
     (active# minus(X1, X2) -> active# X1, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# minus(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X1)
     (active# minus(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X2)
     (active# minus(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# minus(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# minus(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# minus(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# minus(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# cons(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# from X -> cons#(X, from s X))
     (active# cons(X1, X2) -> active# X1, active# from X -> from# s X)
     (active# cons(X1, X2) -> active# X1, active# from X -> from# active X)
     (active# cons(X1, X2) -> active# X1, active# from X -> s# X)
     (active# cons(X1, X2) -> active# X1, active# from X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# s X -> s# active X)
     (active# cons(X1, X2) -> active# X1, active# s X -> active# X)
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# cons(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# minus(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# minus(s X, s Y) -> minus#(X, Y))
     (active# cons(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# quot(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# cons(X1, X2) -> active# X1, active# quot(s X, s Y) -> minus#(X, Y))
     (active# cons(X1, X2) -> active# X1, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# cons(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X1)
     (active# cons(X1, X2) -> active# X1, active# zWquot(X1, X2) -> active# X2)
     (active# cons(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# cons(X1, X2) -> active# X1, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# cons(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# cons(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# cons(X1, X2) -> active# X1, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (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)
     (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# sel(X1, X2) -> sel#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# minus(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# minus(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# quot(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# quot(X1, X2) -> proper# X2)
     (top# mark X -> proper# X, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (top# mark X -> proper# X, proper# zWquot(X1, X2) -> proper# X1)
     (top# mark X -> proper# X, proper# zWquot(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# cons(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# from X -> from# proper X)
     (proper# from X -> proper# X, proper# from X -> proper# X)
     (proper# from X -> proper# X, proper# s X -> s# proper X)
     (proper# from X -> proper# X, proper# s X -> proper# X)
     (proper# from X -> proper# X, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# sel(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# sel(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# minus(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# minus(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# quot(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# quot(X1, X2) -> proper# X2)
     (proper# from X -> proper# X, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# from X -> proper# X, proper# zWquot(X1, X2) -> proper# X1)
     (proper# from X -> proper# X, proper# zWquot(X1, X2) -> proper# X2)
     (active# from X -> active# X, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# from X -> active# X, active# cons(X1, X2) -> active# X1)
     (active# from X -> active# X, active# from X -> cons#(X, from s X))
     (active# from X -> active# X, active# from X -> from# s X)
     (active# from X -> active# X, active# from X -> from# active X)
     (active# from X -> active# X, active# from X -> s# X)
     (active# from X -> active# X, active# from X -> active# X)
     (active# from X -> active# X, active# s X -> s# active X)
     (active# from X -> active# X, active# s X -> active# X)
     (active# from X -> active# X, active# sel(X1, X2) -> active# X1)
     (active# from X -> active# X, active# sel(X1, X2) -> active# X2)
     (active# from X -> active# X, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# from X -> active# X, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# from X -> active# X, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# from X -> active# X, active# minus(X1, X2) -> active# X1)
     (active# from X -> active# X, active# minus(X1, X2) -> active# X2)
     (active# from X -> active# X, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# from X -> active# X, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# from X -> active# X, active# minus(s X, s Y) -> minus#(X, Y))
     (active# from X -> active# X, active# quot(X1, X2) -> active# X1)
     (active# from X -> active# X, active# quot(X1, X2) -> active# X2)
     (active# from X -> active# X, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# from X -> active# X, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# from X -> active# X, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# from X -> active# X, active# quot(s X, s Y) -> minus#(X, Y))
     (active# from X -> active# X, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# from X -> active# X, active# zWquot(X1, X2) -> active# X1)
     (active# from X -> active# X, active# zWquot(X1, X2) -> active# X2)
     (active# from X -> active# X, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# from X -> active# X, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# from X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# from X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# from X -> active# X, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (s# ok X -> s# X, s# mark X -> s# X)
     (s# ok X -> s# X, s# ok X -> s# X)
     (from# ok X -> from# X, from# mark X -> from# X)
     (from# ok X -> from# X, from# ok X -> from# X)
     (zWquot#(ok X1, ok X2) -> zWquot#(X1, X2), zWquot#(X1, mark X2) -> zWquot#(X1, X2))
     (zWquot#(ok X1, ok X2) -> zWquot#(X1, X2), zWquot#(mark X1, X2) -> zWquot#(X1, X2))
     (zWquot#(ok X1, ok X2) -> zWquot#(X1, X2), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (zWquot#(X1, mark X2) -> zWquot#(X1, X2), zWquot#(X1, mark X2) -> zWquot#(X1, X2))
     (zWquot#(X1, mark X2) -> zWquot#(X1, X2), zWquot#(mark X1, X2) -> zWquot#(X1, X2))
     (zWquot#(X1, mark X2) -> zWquot#(X1, X2), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (quot#(mark X1, X2) -> quot#(X1, X2), quot#(X1, mark X2) -> quot#(X1, X2))
     (quot#(mark X1, X2) -> quot#(X1, X2), quot#(mark X1, X2) -> quot#(X1, X2))
     (quot#(mark X1, X2) -> quot#(X1, X2), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (minus#(ok X1, ok X2) -> minus#(X1, X2), minus#(X1, mark X2) -> minus#(X1, X2))
     (minus#(ok X1, ok X2) -> minus#(X1, X2), minus#(mark X1, X2) -> minus#(X1, X2))
     (minus#(ok X1, ok X2) -> minus#(X1, X2), minus#(ok X1, ok X2) -> minus#(X1, X2))
     (minus#(X1, mark X2) -> minus#(X1, X2), minus#(X1, mark X2) -> minus#(X1, X2))
     (minus#(X1, mark X2) -> minus#(X1, X2), minus#(mark X1, X2) -> minus#(X1, X2))
     (minus#(X1, mark X2) -> minus#(X1, X2), minus#(ok X1, ok X2) -> minus#(X1, X2))
     (sel#(mark X1, X2) -> sel#(X1, X2), sel#(X1, mark X2) -> sel#(X1, X2))
     (sel#(mark X1, X2) -> sel#(X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (sel#(mark X1, X2) -> sel#(X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (cons#(ok X1, ok X2) -> cons#(X1, X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2), zWquot#(X1, mark X2) -> zWquot#(X1, X2))
     (proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2), zWquot#(mark X1, X2) -> zWquot#(X1, X2))
     (proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (proper# minus(X1, X2) -> minus#(proper X1, proper X2), minus#(X1, mark X2) -> minus#(X1, X2))
     (proper# minus(X1, X2) -> minus#(proper X1, proper X2), minus#(mark X1, X2) -> minus#(X1, X2))
     (proper# minus(X1, X2) -> minus#(proper X1, proper X2), minus#(ok X1, ok X2) -> minus#(X1, X2))
     (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(mark X1, X2) -> cons#(X1, X2))
     (proper# cons(X1, X2) -> cons#(proper X1, proper X2), cons#(ok X1, ok X2) -> cons#(X1, X2))
     (active# quot(s X, s Y) -> quot#(minus(X, Y), s Y), quot#(X1, mark X2) -> quot#(X1, X2))
     (active# quot(s X, s Y) -> quot#(minus(X, Y), s Y), quot#(mark X1, X2) -> quot#(X1, X2))
     (active# quot(s X, s Y) -> quot#(minus(X, Y), s Y), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (active# minus(X1, X2) -> minus#(X1, active X2), minus#(X1, mark X2) -> minus#(X1, X2))
     (active# minus(X1, X2) -> minus#(X1, active X2), minus#(ok X1, ok X2) -> minus#(X1, X2))
     (active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS), zWquot#(X1, mark X2) -> zWquot#(X1, X2))
     (active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS), zWquot#(mark X1, X2) -> zWquot#(X1, X2))
     (active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS), zWquot#(ok X1, ok X2) -> zWquot#(X1, X2))
     (active# quot(X1, X2) -> quot#(active X1, X2), quot#(mark X1, X2) -> quot#(X1, X2))
     (active# quot(X1, X2) -> quot#(active X1, X2), quot#(ok X1, ok X2) -> quot#(X1, X2))
     (active# sel(X1, X2) -> sel#(active X1, X2), sel#(mark X1, X2) -> sel#(X1, X2))
     (active# sel(X1, X2) -> sel#(active X1, X2), sel#(ok X1, ok X2) -> sel#(X1, X2))
     (proper# zWquot(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# zWquot(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# zWquot(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# zWquot(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# zWquot(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X2, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X2, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X2)
     (proper# zWquot(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# zWquot(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X1)
     (proper# zWquot(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# minus(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# minus(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# minus(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# minus(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X2, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X2, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X2)
     (proper# minus(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# minus(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X1)
     (proper# minus(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> cons#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# cons(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# from X -> from# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# from X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# s X -> s# proper X)
     (proper# cons(X1, X2) -> proper# X2, proper# s X -> proper# X)
     (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> sel#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# sel(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# minus(X1, X2) -> minus#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# minus(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# quot(X1, X2) -> quot#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# quot(X1, X2) -> proper# X2)
     (proper# cons(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> zWquot#(proper X1, proper X2))
     (proper# cons(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X1)
     (proper# cons(X1, X2) -> proper# X2, proper# zWquot(X1, X2) -> proper# X2)
     (active# quot(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# quot(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
     (active# quot(X1, X2) -> active# X2, active# from X -> from# s X)
     (active# quot(X1, X2) -> active# X2, active# from X -> from# active X)
     (active# quot(X1, X2) -> active# X2, active# from X -> s# X)
     (active# quot(X1, X2) -> active# X2, active# from X -> active# X)
     (active# quot(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# quot(X1, X2) -> active# X2, active# s X -> active# X)
     (active# quot(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# quot(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# quot(X1, X2) -> active# X2, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# quot(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# quot(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# quot(X1, X2) -> active# X2, active# minus(s X, s Y) -> minus#(X, Y))
     (active# quot(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# quot(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# quot(X1, X2) -> active# X2, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# quot(X1, X2) -> active# X2, active# quot(s X, s Y) -> minus#(X, Y))
     (active# quot(X1, X2) -> active# X2, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# quot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X1)
     (active# quot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X2)
     (active# quot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# quot(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# quot(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# quot(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# quot(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> cons#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# cons(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# from X -> cons#(X, from s X))
     (active# sel(X1, X2) -> active# X2, active# from X -> from# s X)
     (active# sel(X1, X2) -> active# X2, active# from X -> from# active X)
     (active# sel(X1, X2) -> active# X2, active# from X -> s# X)
     (active# sel(X1, X2) -> active# X2, active# from X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# s X -> s# active X)
     (active# sel(X1, X2) -> active# X2, active# s X -> active# X)
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# sel(X1, X2) -> sel#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# sel(s N, cons(X, XS)) -> sel#(N, XS))
     (active# sel(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# minus(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# minus(X1, X2) -> minus#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# minus(s X, s Y) -> minus#(X, Y))
     (active# sel(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# quot(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# quot(X1, X2) -> quot#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# quot(s X, s Y) -> s# quot(minus(X, Y), s Y))
     (active# sel(X1, X2) -> active# X2, active# quot(s X, s Y) -> minus#(X, Y))
     (active# sel(X1, X2) -> active# X2, active# quot(s X, s Y) -> quot#(minus(X, Y), s Y))
     (active# sel(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X1)
     (active# sel(X1, X2) -> active# X2, active# zWquot(X1, X2) -> active# X2)
     (active# sel(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(X1, active X2))
     (active# sel(X1, X2) -> active# X2, active# zWquot(X1, X2) -> zWquot#(active X1, X2))
     (active# sel(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> cons#(quot(X, Y), zWquot(XS, YS)))
     (active# sel(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y))
     (active# sel(X1, X2) -> active# X2, active# zWquot(cons(X, XS), cons(Y, YS)) -> zWquot#(XS, YS))
     (top# mark X -> top# proper X, top# mark X -> proper# X)
     (top# mark X -> top# proper X, top# mark X -> top# proper X)
     (top# mark X -> top# proper X, top# ok X -> active# X)
     (top# mark X -> top# proper X, top# ok X -> top# active X)
     (proper# from X -> from# proper X, from# mark X -> from# X)
     (proper# from X -> from# proper X, from# ok X -> from# X)
     (active# from X -> from# active X, from# mark X -> from# X)
     (active# from X -> from# active X, from# ok X -> from# X)
     (active# zWquot(cons(X, XS), cons(Y, YS)) -> quot#(X, Y), quot#(ok X1, ok X2) -> quot#(X1, X2))
    }
    STATUS:
     arrows: 0.862491
     SCCS (10):
      Scc:
       {top# mark X -> top# proper X,
          top# ok X -> top# active X}
      Scc:
       {  active# cons(X1, X2) -> active# X1,
                active# from X -> active# X,
                   active# s X -> active# X,
           active# sel(X1, X2) -> active# X1,
           active# sel(X1, X2) -> active# X2,
         active# minus(X1, X2) -> active# X1,
         active# minus(X1, X2) -> active# X2,
          active# quot(X1, X2) -> active# X1,
          active# quot(X1, X2) -> active# X2,
        active# zWquot(X1, X2) -> active# X1,
        active# zWquot(X1, X2) -> active# X2}
      Scc:
       {  proper# cons(X1, X2) -> proper# X1,
          proper# cons(X1, X2) -> proper# X2,
                proper# from X -> proper# X,
                   proper# s X -> proper# X,
           proper# sel(X1, X2) -> proper# X1,
           proper# sel(X1, X2) -> proper# X2,
         proper# minus(X1, X2) -> proper# X1,
         proper# minus(X1, X2) -> proper# X2,
          proper# quot(X1, X2) -> proper# X1,
          proper# quot(X1, X2) -> proper# X2,
        proper# zWquot(X1, X2) -> proper# X1,
        proper# zWquot(X1, X2) -> proper# X2}
      Scc:
       { zWquot#(X1, mark X2) -> zWquot#(X1, X2),
         zWquot#(mark X1, X2) -> zWquot#(X1, X2),
        zWquot#(ok X1, ok X2) -> zWquot#(X1, X2)}
      Scc:
       { minus#(X1, mark X2) -> minus#(X1, X2),
         minus#(mark X1, X2) -> minus#(X1, X2),
        minus#(ok X1, ok X2) -> minus#(X1, X2)}
      Scc:
       { sel#(X1, mark X2) -> sel#(X1, X2),
         sel#(mark X1, X2) -> sel#(X1, X2),
        sel#(ok X1, ok X2) -> sel#(X1, X2)}
      Scc:
       { cons#(mark X1, X2) -> cons#(X1, X2),
        cons#(ok X1, ok X2) -> cons#(X1, X2)}
      Scc:
       {s# mark X -> s# X,
          s# ok X -> s# X}
      Scc:
       {from# mark X -> from# X,
          from# ok X -> from# X}
      Scc:
       { quot#(X1, mark X2) -> quot#(X1, X2),
         quot#(mark X1, X2) -> quot#(X1, X2),
        quot#(ok X1, ok X2) -> quot#(X1, X2)}
      
      SCC (2):
       Strict:
        {top# mark X -> top# proper X,
           top# ok X -> top# active X}
       Weak:
       {                      cons(mark X1, X2) -> mark cons(X1, X2),
                             cons(ok X1, ok X2) -> ok cons(X1, X2),
                                    from mark X -> mark from X,
                                      from ok X -> ok from X,
                                       s mark X -> mark s X,
                                         s ok X -> ok s X,
                            active cons(X1, X2) -> cons(active X1, X2),
                                  active from X -> mark cons(X, from s X),
                                  active from X -> from active X,
                                     active s X -> s active X,
                             active sel(X1, X2) -> sel(X1, active X2),
                             active sel(X1, X2) -> sel(active X1, X2),
                   active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                   active sel(0(), cons(X, XS)) -> mark X,
                           active minus(X, 0()) -> mark 0(),
                           active minus(X1, X2) -> minus(X1, active X2),
                           active minus(X1, X2) -> minus(active X1, X2),
                         active minus(s X, s Y) -> mark minus(X, Y),
                            active quot(X1, X2) -> quot(X1, active X2),
                            active quot(X1, X2) -> quot(active X1, X2),
                          active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                          active quot(0(), s Y) -> mark 0(),
                       active zWquot(XS, nil()) -> mark nil(),
                          active zWquot(X1, X2) -> zWquot(X1, active X2),
                          active zWquot(X1, X2) -> zWquot(active X1, X2),
        active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                       active zWquot(nil(), XS) -> mark nil(),
                               sel(X1, mark X2) -> mark sel(X1, X2),
                               sel(mark X1, X2) -> mark sel(X1, X2),
                              sel(ok X1, ok X2) -> ok sel(X1, X2),
                             minus(X1, mark X2) -> mark minus(X1, X2),
                             minus(mark X1, X2) -> mark minus(X1, X2),
                            minus(ok X1, ok X2) -> ok minus(X1, X2),
                              quot(X1, mark X2) -> mark quot(X1, X2),
                              quot(mark X1, X2) -> mark quot(X1, X2),
                             quot(ok X1, ok X2) -> ok quot(X1, X2),
                            zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                            zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                           zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                            proper cons(X1, X2) -> cons(proper X1, proper X2),
                                  proper from X -> from proper X,
                                     proper s X -> s proper X,
                             proper sel(X1, X2) -> sel(proper X1, proper X2),
                                     proper 0() -> ok 0(),
                           proper minus(X1, X2) -> minus(proper X1, proper X2),
                            proper quot(X1, X2) -> quot(proper X1, proper X2),
                                   proper nil() -> ok nil(),
                          proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                     top mark X -> top proper X,
                                       top ok X -> top active X}
       Fail
      
      SCC (11):
       Strict:
        {  active# cons(X1, X2) -> active# X1,
                 active# from X -> active# X,
                    active# s X -> active# X,
            active# sel(X1, X2) -> active# X1,
            active# sel(X1, X2) -> active# X2,
          active# minus(X1, X2) -> active# X1,
          active# minus(X1, X2) -> active# X2,
           active# quot(X1, X2) -> active# X1,
           active# quot(X1, X2) -> active# X2,
         active# zWquot(X1, X2) -> active# X1,
         active# zWquot(X1, X2) -> active# X2}
       Weak:
       {                      cons(mark X1, X2) -> mark cons(X1, X2),
                             cons(ok X1, ok X2) -> ok cons(X1, X2),
                                    from mark X -> mark from X,
                                      from ok X -> ok from X,
                                       s mark X -> mark s X,
                                         s ok X -> ok s X,
                            active cons(X1, X2) -> cons(active X1, X2),
                                  active from X -> mark cons(X, from s X),
                                  active from X -> from active X,
                                     active s X -> s active X,
                             active sel(X1, X2) -> sel(X1, active X2),
                             active sel(X1, X2) -> sel(active X1, X2),
                   active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                   active sel(0(), cons(X, XS)) -> mark X,
                           active minus(X, 0()) -> mark 0(),
                           active minus(X1, X2) -> minus(X1, active X2),
                           active minus(X1, X2) -> minus(active X1, X2),
                         active minus(s X, s Y) -> mark minus(X, Y),
                            active quot(X1, X2) -> quot(X1, active X2),
                            active quot(X1, X2) -> quot(active X1, X2),
                          active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                          active quot(0(), s Y) -> mark 0(),
                       active zWquot(XS, nil()) -> mark nil(),
                          active zWquot(X1, X2) -> zWquot(X1, active X2),
                          active zWquot(X1, X2) -> zWquot(active X1, X2),
        active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                       active zWquot(nil(), XS) -> mark nil(),
                               sel(X1, mark X2) -> mark sel(X1, X2),
                               sel(mark X1, X2) -> mark sel(X1, X2),
                              sel(ok X1, ok X2) -> ok sel(X1, X2),
                             minus(X1, mark X2) -> mark minus(X1, X2),
                             minus(mark X1, X2) -> mark minus(X1, X2),
                            minus(ok X1, ok X2) -> ok minus(X1, X2),
                              quot(X1, mark X2) -> mark quot(X1, X2),
                              quot(mark X1, X2) -> mark quot(X1, X2),
                             quot(ok X1, ok X2) -> ok quot(X1, X2),
                            zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                            zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                           zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                            proper cons(X1, X2) -> cons(proper X1, proper X2),
                                  proper from X -> from proper X,
                                     proper s X -> s proper X,
                             proper sel(X1, X2) -> sel(proper X1, proper X2),
                                     proper 0() -> ok 0(),
                           proper minus(X1, X2) -> minus(proper X1, proper X2),
                            proper quot(X1, X2) -> quot(proper X1, proper X2),
                                   proper nil() -> ok nil(),
                          proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                     top mark X -> top proper X,
                                       top ok X -> top active X}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [cons](x0, x1) = x0,
         
         [sel](x0, x1) = x0 + x1,
         
         [minus](x0, x1) = x0 + x1,
         
         [quot](x0, x1) = x0 + x1,
         
         [zWquot](x0, x1) = x0 + x1 + 1,
         
         [mark](x0) = x0,
         
         [from](x0) = x0,
         
         [s](x0) = x0,
         
         [active](x0) = 0,
         
         [proper](x0) = 0,
         
         [ok](x0) = x0 + 1,
         
         [top](x0) = 0,
         
         [0] = 0,
         
         [nil] = 1,
         
         [active#](x0) = x0
        Strict:
         active# zWquot(X1, X2) -> active# X2
         1 + 1X1 + 1X2 >= 0 + 1X2
         active# zWquot(X1, X2) -> active# X1
         1 + 1X1 + 1X2 >= 0 + 1X1
         active# quot(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# quot(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# minus(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# minus(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# sel(X1, X2) -> active# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         active# sel(X1, X2) -> active# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         active# s X -> active# X
         0 + 1X >= 0 + 1X
         active# from X -> active# X
         0 + 1X >= 0 + 1X
         active# cons(X1, X2) -> active# X1
         0 + 1X1 + 0X2 >= 0 + 1X1
        Weak:
         top ok X -> top active X
         0 + 0X >= 0 + 0X
         top mark X -> top proper X
         0 + 0X >= 0 + 0X
         proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper nil() -> ok nil()
         0 >= 2
         proper quot(X1, X2) -> quot(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         proper minus(X1, X2) -> minus(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         proper 0() -> ok 0()
         0 >= 1
         proper sel(X1, X2) -> sel(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         proper s X -> s proper X
         0 + 0X >= 0 + 0X
         proper from X -> from proper X
         0 + 0X >= 0 + 0X
         proper cons(X1, X2) -> cons(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
         3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         zWquot(mark X1, X2) -> mark zWquot(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         zWquot(X1, mark X2) -> mark zWquot(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         quot(ok X1, ok X2) -> ok quot(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         quot(mark X1, X2) -> mark quot(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         quot(X1, mark X2) -> mark quot(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         minus(ok X1, ok X2) -> ok minus(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         minus(mark X1, X2) -> mark minus(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         minus(X1, mark X2) -> mark minus(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         sel(ok X1, ok X2) -> ok sel(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         sel(mark X1, X2) -> mark sel(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         sel(X1, mark X2) -> mark sel(X1, X2)
         0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
         active zWquot(nil(), XS) -> mark nil()
         0 + 0XS >= 1
         active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
         0 + 0X + 0XS + 0Y + 0YS >= 0 + 1X + 0XS + 1Y + 0YS
         active zWquot(X1, X2) -> zWquot(active X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
         active zWquot(X1, X2) -> zWquot(X1, active X2)
         0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
         active zWquot(XS, nil()) -> mark nil()
         0 + 0XS >= 1
         active quot(0(), s Y) -> mark 0()
         0 + 0Y >= 0
         active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
         0 + 0X + 0Y >= 0 + 1X + 2Y
         active quot(X1, X2) -> quot(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active quot(X1, X2) -> quot(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active minus(s X, s Y) -> mark minus(X, Y)
         0 + 0X + 0Y >= 0 + 1X + 1Y
         active minus(X1, X2) -> minus(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active minus(X1, X2) -> minus(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active minus(X, 0()) -> mark 0()
         0 + 0X >= 0
         active sel(0(), cons(X, XS)) -> mark X
         0 + 0X + 0XS >= 0 + 1X
         active sel(s N, cons(X, XS)) -> mark sel(N, XS)
         0 + 0X + 0XS + 0N >= 0 + 1XS + 1N
         active sel(X1, X2) -> sel(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active sel(X1, X2) -> sel(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active s X -> s active X
         0 + 0X >= 0 + 0X
         active from X -> from active X
         0 + 0X >= 0 + 0X
         active from X -> mark cons(X, from s X)
         0 + 0X >= 0 + 1X
         active cons(X1, X2) -> cons(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         s ok X -> ok s X
         1 + 1X >= 1 + 1X
         s mark X -> mark s X
         0 + 1X >= 0 + 1X
         from ok X -> ok from X
         1 + 1X >= 1 + 1X
         from mark X -> mark from X
         0 + 1X >= 0 + 1X
         cons(ok X1, ok X2) -> ok cons(X1, X2)
         1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
         cons(mark X1, X2) -> mark cons(X1, X2)
         0 + 1X1 + 0X2 >= 0 + 1X1 + 0X2
       SCCS (1):
        Scc:
         { active# cons(X1, X2) -> active# X1,
                 active# from X -> active# X,
                    active# s X -> active# X,
            active# sel(X1, X2) -> active# X1,
            active# sel(X1, X2) -> active# X2,
          active# minus(X1, X2) -> active# X1,
          active# minus(X1, X2) -> active# X2,
           active# quot(X1, X2) -> active# X1,
           active# quot(X1, X2) -> active# X2}
        
        SCC (9):
         Strict:
          { active# cons(X1, X2) -> active# X1,
                  active# from X -> active# X,
                     active# s X -> active# X,
             active# sel(X1, X2) -> active# X1,
             active# sel(X1, X2) -> active# X2,
           active# minus(X1, X2) -> active# X1,
           active# minus(X1, X2) -> active# X2,
            active# quot(X1, X2) -> active# X1,
            active# quot(X1, X2) -> active# X2}
         Weak:
         {                      cons(mark X1, X2) -> mark cons(X1, X2),
                               cons(ok X1, ok X2) -> ok cons(X1, X2),
                                      from mark X -> mark from X,
                                        from ok X -> ok from X,
                                         s mark X -> mark s X,
                                           s ok X -> ok s X,
                              active cons(X1, X2) -> cons(active X1, X2),
                                    active from X -> mark cons(X, from s X),
                                    active from X -> from active X,
                                       active s X -> s active X,
                               active sel(X1, X2) -> sel(X1, active X2),
                               active sel(X1, X2) -> sel(active X1, X2),
                     active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                     active sel(0(), cons(X, XS)) -> mark X,
                             active minus(X, 0()) -> mark 0(),
                             active minus(X1, X2) -> minus(X1, active X2),
                             active minus(X1, X2) -> minus(active X1, X2),
                           active minus(s X, s Y) -> mark minus(X, Y),
                              active quot(X1, X2) -> quot(X1, active X2),
                              active quot(X1, X2) -> quot(active X1, X2),
                            active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                            active quot(0(), s Y) -> mark 0(),
                         active zWquot(XS, nil()) -> mark nil(),
                            active zWquot(X1, X2) -> zWquot(X1, active X2),
                            active zWquot(X1, X2) -> zWquot(active X1, X2),
          active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                         active zWquot(nil(), XS) -> mark nil(),
                                 sel(X1, mark X2) -> mark sel(X1, X2),
                                 sel(mark X1, X2) -> mark sel(X1, X2),
                                sel(ok X1, ok X2) -> ok sel(X1, X2),
                               minus(X1, mark X2) -> mark minus(X1, X2),
                               minus(mark X1, X2) -> mark minus(X1, X2),
                              minus(ok X1, ok X2) -> ok minus(X1, X2),
                                quot(X1, mark X2) -> mark quot(X1, X2),
                                quot(mark X1, X2) -> mark quot(X1, X2),
                               quot(ok X1, ok X2) -> ok quot(X1, X2),
                              zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                              zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                             zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                              proper cons(X1, X2) -> cons(proper X1, proper X2),
                                    proper from X -> from proper X,
                                       proper s X -> s proper X,
                               proper sel(X1, X2) -> sel(proper X1, proper X2),
                                       proper 0() -> ok 0(),
                             proper minus(X1, X2) -> minus(proper X1, proper X2),
                              proper quot(X1, X2) -> quot(proper X1, proper X2),
                                     proper nil() -> ok nil(),
                            proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                       top mark X -> top proper X,
                                         top ok X -> top active X}
         POLY:
          Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
          Interpretation:
           [cons](x0, x1) = x0,
           
           [sel](x0, x1) = x0 + x1,
           
           [minus](x0, x1) = x0 + x1,
           
           [quot](x0, x1) = x0 + x1 + 1,
           
           [zWquot](x0, x1) = x0 + 1,
           
           [mark](x0) = x0,
           
           [from](x0) = x0,
           
           [s](x0) = x0,
           
           [active](x0) = 0,
           
           [proper](x0) = 0,
           
           [ok](x0) = x0 + 1,
           
           [top](x0) = 0,
           
           [0] = 0,
           
           [nil] = 1,
           
           [active#](x0) = x0
          Strict:
           active# quot(X1, X2) -> active# X2
           1 + 1X1 + 1X2 >= 0 + 1X2
           active# quot(X1, X2) -> active# X1
           1 + 1X1 + 1X2 >= 0 + 1X1
           active# minus(X1, X2) -> active# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           active# minus(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
           active# sel(X1, X2) -> active# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           active# sel(X1, X2) -> active# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
           active# s X -> active# X
           0 + 1X >= 0 + 1X
           active# from X -> active# X
           0 + 1X >= 0 + 1X
           active# cons(X1, X2) -> active# X1
           0 + 1X1 + 0X2 >= 0 + 1X1
          Weak:
           top ok X -> top active X
           0 + 0X >= 0 + 0X
           top mark X -> top proper X
           0 + 0X >= 0 + 0X
           proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper nil() -> ok nil()
           0 >= 2
           proper quot(X1, X2) -> quot(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper minus(X1, X2) -> minus(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper 0() -> ok 0()
           0 >= 1
           proper sel(X1, X2) -> sel(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           proper s X -> s proper X
           0 + 0X >= 0 + 0X
           proper from X -> from proper X
           0 + 0X >= 0 + 0X
           proper cons(X1, X2) -> cons(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           zWquot(mark X1, X2) -> mark zWquot(X1, X2)
           1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
           zWquot(X1, mark X2) -> mark zWquot(X1, X2)
           1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
           quot(ok X1, ok X2) -> ok quot(X1, X2)
           3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           quot(mark X1, X2) -> mark quot(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           quot(X1, mark X2) -> mark quot(X1, X2)
           1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           minus(ok X1, ok X2) -> ok minus(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           minus(mark X1, X2) -> mark minus(X1, X2)
           0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
           minus(X1, mark X2) -> mark minus(X1, X2)
           0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
           sel(ok X1, ok X2) -> ok sel(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           sel(mark X1, X2) -> mark sel(X1, X2)
           0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
           sel(X1, mark X2) -> mark sel(X1, X2)
           0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
           active zWquot(nil(), XS) -> mark nil()
           0 + 0XS >= 1
           active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
           0 + 0X + 0XS + 0Y + 0YS >= 1 + 1X + 0XS + 1Y + 0YS
           active zWquot(X1, X2) -> zWquot(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
           active zWquot(X1, X2) -> zWquot(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           active zWquot(XS, nil()) -> mark nil()
           0 + 0XS >= 1
           active quot(0(), s Y) -> mark 0()
           0 + 0Y >= 0
           active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
           0 + 0X + 0Y >= 1 + 1X + 2Y
           active quot(X1, X2) -> quot(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
           active quot(X1, X2) -> quot(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
           active minus(s X, s Y) -> mark minus(X, Y)
           0 + 0X + 0Y >= 0 + 1X + 1Y
           active minus(X1, X2) -> minus(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           active minus(X1, X2) -> minus(X1, active X2)
           0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
           active minus(X, 0()) -> mark 0()
           0 + 0X >= 0
           active sel(0(), cons(X, XS)) -> mark X
           0 + 0X + 0XS >= 0 + 1X
           active sel(s N, cons(X, XS)) -> mark sel(N, XS)
           0 + 0X + 0XS + 0N >= 0 + 1XS + 1N
           active sel(X1, X2) -> sel(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           active sel(X1, X2) -> sel(X1, active X2)
           0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
           active s X -> s active X
           0 + 0X >= 0 + 0X
           active from X -> from active X
           0 + 0X >= 0 + 0X
           active from X -> mark cons(X, from s X)
           0 + 0X >= 0 + 1X
           active cons(X1, X2) -> cons(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           s ok X -> ok s X
           1 + 1X >= 1 + 1X
           s mark X -> mark s X
           0 + 1X >= 0 + 1X
           from ok X -> ok from X
           1 + 1X >= 1 + 1X
           from mark X -> mark from X
           0 + 1X >= 0 + 1X
           cons(ok X1, ok X2) -> ok cons(X1, X2)
           1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
           cons(mark X1, X2) -> mark cons(X1, X2)
           0 + 1X1 + 0X2 >= 0 + 1X1 + 0X2
         SCCS (1):
          Scc:
           { active# cons(X1, X2) -> active# X1,
                   active# from X -> active# X,
                      active# s X -> active# X,
              active# sel(X1, X2) -> active# X1,
              active# sel(X1, X2) -> active# X2,
            active# minus(X1, X2) -> active# X1,
            active# minus(X1, X2) -> active# X2}
          
          SCC (7):
           Strict:
            { active# cons(X1, X2) -> active# X1,
                    active# from X -> active# X,
                       active# s X -> active# X,
               active# sel(X1, X2) -> active# X1,
               active# sel(X1, X2) -> active# X2,
             active# minus(X1, X2) -> active# X1,
             active# minus(X1, X2) -> active# X2}
           Weak:
           {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                                        from mark X -> mark from X,
                                          from ok X -> ok from X,
                                           s mark X -> mark s X,
                                             s ok X -> ok s X,
                                active cons(X1, X2) -> cons(active X1, X2),
                                      active from X -> mark cons(X, from s X),
                                      active from X -> from active X,
                                         active s X -> s active X,
                                 active sel(X1, X2) -> sel(X1, active X2),
                                 active sel(X1, X2) -> sel(active X1, X2),
                       active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                       active sel(0(), cons(X, XS)) -> mark X,
                               active minus(X, 0()) -> mark 0(),
                               active minus(X1, X2) -> minus(X1, active X2),
                               active minus(X1, X2) -> minus(active X1, X2),
                             active minus(s X, s Y) -> mark minus(X, Y),
                                active quot(X1, X2) -> quot(X1, active X2),
                                active quot(X1, X2) -> quot(active X1, X2),
                              active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                              active quot(0(), s Y) -> mark 0(),
                           active zWquot(XS, nil()) -> mark nil(),
                              active zWquot(X1, X2) -> zWquot(X1, active X2),
                              active zWquot(X1, X2) -> zWquot(active X1, X2),
            active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                           active zWquot(nil(), XS) -> mark nil(),
                                   sel(X1, mark X2) -> mark sel(X1, X2),
                                   sel(mark X1, X2) -> mark sel(X1, X2),
                                  sel(ok X1, ok X2) -> ok sel(X1, X2),
                                 minus(X1, mark X2) -> mark minus(X1, X2),
                                 minus(mark X1, X2) -> mark minus(X1, X2),
                                minus(ok X1, ok X2) -> ok minus(X1, X2),
                                  quot(X1, mark X2) -> mark quot(X1, X2),
                                  quot(mark X1, X2) -> mark quot(X1, X2),
                                 quot(ok X1, ok X2) -> ok quot(X1, X2),
                                zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                               zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                proper cons(X1, X2) -> cons(proper X1, proper X2),
                                      proper from X -> from proper X,
                                         proper s X -> s proper X,
                                 proper sel(X1, X2) -> sel(proper X1, proper X2),
                                         proper 0() -> ok 0(),
                               proper minus(X1, X2) -> minus(proper X1, proper X2),
                                proper quot(X1, X2) -> quot(proper X1, proper X2),
                                       proper nil() -> ok nil(),
                              proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                         top mark X -> top proper X,
                                           top ok X -> top active X}
           POLY:
            Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
            Interpretation:
             [cons](x0, x1) = x0,
             
             [sel](x0, x1) = x0 + x1,
             
             [minus](x0, x1) = x0 + x1 + 1,
             
             [quot](x0, x1) = 0,
             
             [zWquot](x0, x1) = x0 + x1 + 1,
             
             [mark](x0) = x0 + 1,
             
             [from](x0) = x0,
             
             [s](x0) = x0,
             
             [active](x0) = 0,
             
             [proper](x0) = 0,
             
             [ok](x0) = 0,
             
             [top](x0) = 0,
             
             [0] = 0,
             
             [nil] = 1,
             
             [active#](x0) = x0
            Strict:
             active# minus(X1, X2) -> active# X2
             1 + 1X1 + 1X2 >= 0 + 1X2
             active# minus(X1, X2) -> active# X1
             1 + 1X1 + 1X2 >= 0 + 1X1
             active# sel(X1, X2) -> active# X2
             0 + 1X1 + 1X2 >= 0 + 1X2
             active# sel(X1, X2) -> active# X1
             0 + 1X1 + 1X2 >= 0 + 1X1
             active# s X -> active# X
             0 + 1X >= 0 + 1X
             active# from X -> active# X
             0 + 1X >= 0 + 1X
             active# cons(X1, X2) -> active# X1
             0 + 1X1 + 0X2 >= 0 + 1X1
            Weak:
             top ok X -> top active X
             0 + 0X >= 0 + 0X
             top mark X -> top proper X
             0 + 0X >= 0 + 0X
             proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             proper nil() -> ok nil()
             0 >= 0
             proper quot(X1, X2) -> quot(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper minus(X1, X2) -> minus(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             proper 0() -> ok 0()
             0 >= 0
             proper sel(X1, X2) -> sel(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper s X -> s proper X
             0 + 0X >= 0 + 0X
             proper from X -> from proper X
             0 + 0X >= 0 + 0X
             proper cons(X1, X2) -> cons(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
             1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             zWquot(mark X1, X2) -> mark zWquot(X1, X2)
             2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             zWquot(X1, mark X2) -> mark zWquot(X1, X2)
             2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             quot(ok X1, ok X2) -> ok quot(X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             quot(mark X1, X2) -> mark quot(X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             quot(X1, mark X2) -> mark quot(X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             minus(ok X1, ok X2) -> ok minus(X1, X2)
             1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             minus(mark X1, X2) -> mark minus(X1, X2)
             2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             minus(X1, mark X2) -> mark minus(X1, X2)
             2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
             sel(ok X1, ok X2) -> ok sel(X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             sel(mark X1, X2) -> mark sel(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             sel(X1, mark X2) -> mark sel(X1, X2)
             1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             active zWquot(nil(), XS) -> mark nil()
             0 + 0XS >= 2
             active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
             0 + 0X + 0XS + 0Y + 0YS >= 1 + 0X + 0XS + 0Y + 0YS
             active zWquot(X1, X2) -> zWquot(active X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
             active zWquot(X1, X2) -> zWquot(X1, active X2)
             0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
             active zWquot(XS, nil()) -> mark nil()
             0 + 0XS >= 2
             active quot(0(), s Y) -> mark 0()
             0 + 0Y >= 1
             active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
             0 + 0X + 0Y >= 1 + 0X + 0Y
             active quot(X1, X2) -> quot(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             active quot(X1, X2) -> quot(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             active minus(s X, s Y) -> mark minus(X, Y)
             0 + 0X + 0Y >= 2 + 1X + 1Y
             active minus(X1, X2) -> minus(active X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
             active minus(X1, X2) -> minus(X1, active X2)
             0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
             active minus(X, 0()) -> mark 0()
             0 + 0X >= 1
             active sel(0(), cons(X, XS)) -> mark X
             0 + 0X + 0XS >= 1 + 1X
             active sel(s N, cons(X, XS)) -> mark sel(N, XS)
             0 + 0X + 0XS + 0N >= 1 + 1XS + 1N
             active sel(X1, X2) -> sel(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             active sel(X1, X2) -> sel(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
             active s X -> s active X
             0 + 0X >= 0 + 0X
             active from X -> from active X
             0 + 0X >= 0 + 0X
             active from X -> mark cons(X, from s X)
             0 + 0X >= 1 + 1X
             active cons(X1, X2) -> cons(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             s ok X -> ok s X
             0 + 0X >= 0 + 0X
             s mark X -> mark s X
             1 + 1X >= 1 + 1X
             from ok X -> ok from X
             0 + 0X >= 0 + 0X
             from mark X -> mark from X
             1 + 1X >= 1 + 1X
             cons(ok X1, ok X2) -> ok cons(X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             cons(mark X1, X2) -> mark cons(X1, X2)
             1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
           SCCS (1):
            Scc:
             {active# cons(X1, X2) -> active# X1,
                    active# from X -> active# X,
                       active# s X -> active# X,
               active# sel(X1, X2) -> active# X1,
               active# sel(X1, X2) -> active# X2}
            
            SCC (5):
             Strict:
              {active# cons(X1, X2) -> active# X1,
                     active# from X -> active# X,
                        active# s X -> active# X,
                active# sel(X1, X2) -> active# X1,
                active# sel(X1, X2) -> active# X2}
             Weak:
             {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                   cons(ok X1, ok X2) -> ok cons(X1, X2),
                                          from mark X -> mark from X,
                                            from ok X -> ok from X,
                                             s mark X -> mark s X,
                                               s ok X -> ok s X,
                                  active cons(X1, X2) -> cons(active X1, X2),
                                        active from X -> mark cons(X, from s X),
                                        active from X -> from active X,
                                           active s X -> s active X,
                                   active sel(X1, X2) -> sel(X1, active X2),
                                   active sel(X1, X2) -> sel(active X1, X2),
                         active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                         active sel(0(), cons(X, XS)) -> mark X,
                                 active minus(X, 0()) -> mark 0(),
                                 active minus(X1, X2) -> minus(X1, active X2),
                                 active minus(X1, X2) -> minus(active X1, X2),
                               active minus(s X, s Y) -> mark minus(X, Y),
                                  active quot(X1, X2) -> quot(X1, active X2),
                                  active quot(X1, X2) -> quot(active X1, X2),
                                active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                                active quot(0(), s Y) -> mark 0(),
                             active zWquot(XS, nil()) -> mark nil(),
                                active zWquot(X1, X2) -> zWquot(X1, active X2),
                                active zWquot(X1, X2) -> zWquot(active X1, X2),
              active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                             active zWquot(nil(), XS) -> mark nil(),
                                     sel(X1, mark X2) -> mark sel(X1, X2),
                                     sel(mark X1, X2) -> mark sel(X1, X2),
                                    sel(ok X1, ok X2) -> ok sel(X1, X2),
                                   minus(X1, mark X2) -> mark minus(X1, X2),
                                   minus(mark X1, X2) -> mark minus(X1, X2),
                                  minus(ok X1, ok X2) -> ok minus(X1, X2),
                                    quot(X1, mark X2) -> mark quot(X1, X2),
                                    quot(mark X1, X2) -> mark quot(X1, X2),
                                   quot(ok X1, ok X2) -> ok quot(X1, X2),
                                  zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                  zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                                 zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                  proper cons(X1, X2) -> cons(proper X1, proper X2),
                                        proper from X -> from proper X,
                                           proper s X -> s proper X,
                                   proper sel(X1, X2) -> sel(proper X1, proper X2),
                                           proper 0() -> ok 0(),
                                 proper minus(X1, X2) -> minus(proper X1, proper X2),
                                  proper quot(X1, X2) -> quot(proper X1, proper X2),
                                         proper nil() -> ok nil(),
                                proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                           top mark X -> top proper X,
                                             top ok X -> top active X}
             POLY:
              Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
              Interpretation:
               [cons](x0, x1) = x0 + x1,
               
               [sel](x0, x1) = x0 + x1 + 1,
               
               [minus](x0, x1) = x0 + 1,
               
               [quot](x0, x1) = x0 + 1,
               
               [zWquot](x0, x1) = x0 + 1,
               
               [mark](x0) = 1,
               
               [from](x0) = x0,
               
               [s](x0) = x0,
               
               [active](x0) = 0,
               
               [proper](x0) = x0 + 1,
               
               [ok](x0) = x0 + 1,
               
               [top](x0) = 0,
               
               [0] = 1,
               
               [nil] = 1,
               
               [active#](x0) = x0
              Strict:
               active# sel(X1, X2) -> active# X2
               1 + 1X1 + 1X2 >= 0 + 1X2
               active# sel(X1, X2) -> active# X1
               1 + 1X1 + 1X2 >= 0 + 1X1
               active# s X -> active# X
               0 + 1X >= 0 + 1X
               active# from X -> active# X
               0 + 1X >= 0 + 1X
               active# cons(X1, X2) -> active# X1
               0 + 1X1 + 1X2 >= 0 + 1X1
              Weak:
               top ok X -> top active X
               0 + 0X >= 0 + 0X
               top mark X -> top proper X
               0 + 0X >= 0 + 0X
               proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               proper nil() -> ok nil()
               2 >= 2
               proper quot(X1, X2) -> quot(proper X1, proper X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               proper minus(X1, X2) -> minus(proper X1, proper X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               proper 0() -> ok 0()
               2 >= 2
               proper sel(X1, X2) -> sel(proper X1, proper X2)
               2 + 1X1 + 1X2 >= 3 + 1X1 + 1X2
               proper s X -> s proper X
               1 + 1X >= 1 + 1X
               proper from X -> from proper X
               1 + 1X >= 1 + 1X
               proper cons(X1, X2) -> cons(proper X1, proper X2)
               1 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               zWquot(mark X1, X2) -> mark zWquot(X1, X2)
               1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
               zWquot(X1, mark X2) -> mark zWquot(X1, X2)
               2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               quot(ok X1, ok X2) -> ok quot(X1, X2)
               2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
               quot(mark X1, X2) -> mark quot(X1, X2)
               2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               quot(X1, mark X2) -> mark quot(X1, X2)
               1 + 1X1 + 0X2 >= 1 + 0X1 + 0X2
               minus(ok X1, ok X2) -> ok minus(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               minus(mark X1, X2) -> mark minus(X1, X2)
               1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
               minus(X1, mark X2) -> mark minus(X1, X2)
               2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               sel(ok X1, ok X2) -> ok sel(X1, X2)
               3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               sel(mark X1, X2) -> mark sel(X1, X2)
               2 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
               sel(X1, mark X2) -> mark sel(X1, X2)
               2 + 1X1 + 0X2 >= 1 + 0X1 + 0X2
               active zWquot(nil(), XS) -> mark nil()
               0 + 0XS >= 1
               active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
               0 + 0X + 0XS + 0Y + 0YS >= 1 + 0X + 0XS + 0Y + 0YS
               active zWquot(X1, X2) -> zWquot(active X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
               active zWquot(X1, X2) -> zWquot(X1, active X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               active zWquot(XS, nil()) -> mark nil()
               0 + 0XS >= 1
               active quot(0(), s Y) -> mark 0()
               0 + 0Y >= 1
               active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
               0 + 0X + 0Y >= 1 + 0X + 0Y
               active quot(X1, X2) -> quot(active X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               active quot(X1, X2) -> quot(X1, active X2)
               0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
               active minus(s X, s Y) -> mark minus(X, Y)
               0 + 0X + 0Y >= 1 + 0X + 0Y
               active minus(X1, X2) -> minus(active X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
               active minus(X1, X2) -> minus(X1, active X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               active minus(X, 0()) -> mark 0()
               0 + 0X >= 1
               active sel(0(), cons(X, XS)) -> mark X
               0 + 0X + 0XS >= 1 + 0X
               active sel(s N, cons(X, XS)) -> mark sel(N, XS)
               0 + 0X + 0XS + 0N >= 1 + 0XS + 0N
               active sel(X1, X2) -> sel(active X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
               active sel(X1, X2) -> sel(X1, active X2)
               0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
               active s X -> s active X
               0 + 0X >= 0 + 0X
               active from X -> from active X
               0 + 0X >= 0 + 0X
               active from X -> mark cons(X, from s X)
               0 + 0X >= 1 + 0X
               active cons(X1, X2) -> cons(active X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
               s ok X -> ok s X
               1 + 1X >= 1 + 1X
               s mark X -> mark s X
               1 + 0X >= 1 + 0X
               from ok X -> ok from X
               1 + 1X >= 1 + 1X
               from mark X -> mark from X
               1 + 0X >= 1 + 0X
               cons(ok X1, ok X2) -> ok cons(X1, X2)
               2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
               cons(mark X1, X2) -> mark cons(X1, X2)
               1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
             SCCS (1):
              Scc:
               {active# cons(X1, X2) -> active# X1,
                      active# from X -> active# X,
                         active# s X -> active# X}
              
              SCC (3):
               Strict:
                {active# cons(X1, X2) -> active# X1,
                       active# from X -> active# X,
                          active# s X -> active# X}
               Weak:
               {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                     cons(ok X1, ok X2) -> ok cons(X1, X2),
                                            from mark X -> mark from X,
                                              from ok X -> ok from X,
                                               s mark X -> mark s X,
                                                 s ok X -> ok s X,
                                    active cons(X1, X2) -> cons(active X1, X2),
                                          active from X -> mark cons(X, from s X),
                                          active from X -> from active X,
                                             active s X -> s active X,
                                     active sel(X1, X2) -> sel(X1, active X2),
                                     active sel(X1, X2) -> sel(active X1, X2),
                           active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                           active sel(0(), cons(X, XS)) -> mark X,
                                   active minus(X, 0()) -> mark 0(),
                                   active minus(X1, X2) -> minus(X1, active X2),
                                   active minus(X1, X2) -> minus(active X1, X2),
                                 active minus(s X, s Y) -> mark minus(X, Y),
                                    active quot(X1, X2) -> quot(X1, active X2),
                                    active quot(X1, X2) -> quot(active X1, X2),
                                  active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                                  active quot(0(), s Y) -> mark 0(),
                               active zWquot(XS, nil()) -> mark nil(),
                                  active zWquot(X1, X2) -> zWquot(X1, active X2),
                                  active zWquot(X1, X2) -> zWquot(active X1, X2),
                active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                               active zWquot(nil(), XS) -> mark nil(),
                                       sel(X1, mark X2) -> mark sel(X1, X2),
                                       sel(mark X1, X2) -> mark sel(X1, X2),
                                      sel(ok X1, ok X2) -> ok sel(X1, X2),
                                     minus(X1, mark X2) -> mark minus(X1, X2),
                                     minus(mark X1, X2) -> mark minus(X1, X2),
                                    minus(ok X1, ok X2) -> ok minus(X1, X2),
                                      quot(X1, mark X2) -> mark quot(X1, X2),
                                      quot(mark X1, X2) -> mark quot(X1, X2),
                                     quot(ok X1, ok X2) -> ok quot(X1, X2),
                                    zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                    zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                                   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                    proper cons(X1, X2) -> cons(proper X1, proper X2),
                                          proper from X -> from proper X,
                                             proper s X -> s proper X,
                                     proper sel(X1, X2) -> sel(proper X1, proper X2),
                                             proper 0() -> ok 0(),
                                   proper minus(X1, X2) -> minus(proper X1, proper X2),
                                    proper quot(X1, X2) -> quot(proper X1, proper X2),
                                           proper nil() -> ok nil(),
                                  proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                             top mark X -> top proper X,
                                               top ok X -> top active X}
               POLY:
                Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
                Interpretation:
                 [cons](x0, x1) = x0 + x1,
                 
                 [sel](x0, x1) = 0,
                 
                 [minus](x0, x1) = x0 + 1,
                 
                 [quot](x0, x1) = x0 + x1,
                 
                 [zWquot](x0, x1) = x0 + 1,
                 
                 [mark](x0) = 1,
                 
                 [from](x0) = x0,
                 
                 [s](x0) = x0 + 1,
                 
                 [active](x0) = 0,
                 
                 [proper](x0) = 0,
                 
                 [ok](x0) = x0 + 1,
                 
                 [top](x0) = 0,
                 
                 [0] = 1,
                 
                 [nil] = 1,
                 
                 [active#](x0) = x0
                Strict:
                 active# s X -> active# X
                 1 + 1X >= 0 + 1X
                 active# from X -> active# X
                 0 + 1X >= 0 + 1X
                 active# cons(X1, X2) -> active# X1
                 0 + 1X1 + 1X2 >= 0 + 1X1
                Weak:
                 top ok X -> top active X
                 0 + 0X >= 0 + 0X
                 top mark X -> top proper X
                 0 + 0X >= 0 + 0X
                 proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 proper nil() -> ok nil()
                 0 >= 2
                 proper quot(X1, X2) -> quot(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 proper minus(X1, X2) -> minus(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 proper 0() -> ok 0()
                 0 >= 2
                 proper sel(X1, X2) -> sel(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 proper s X -> s proper X
                 0 + 0X >= 1 + 0X
                 proper from X -> from proper X
                 0 + 0X >= 0 + 0X
                 proper cons(X1, X2) -> cons(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
                 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                 zWquot(mark X1, X2) -> mark zWquot(X1, X2)
                 1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
                 zWquot(X1, mark X2) -> mark zWquot(X1, X2)
                 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 quot(ok X1, ok X2) -> ok quot(X1, X2)
                 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                 quot(mark X1, X2) -> mark quot(X1, X2)
                 1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
                 quot(X1, mark X2) -> mark quot(X1, X2)
                 1 + 1X1 + 0X2 >= 1 + 0X1 + 0X2
                 minus(ok X1, ok X2) -> ok minus(X1, X2)
                 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                 minus(mark X1, X2) -> mark minus(X1, X2)
                 1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
                 minus(X1, mark X2) -> mark minus(X1, X2)
                 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 sel(ok X1, ok X2) -> ok sel(X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 sel(mark X1, X2) -> mark sel(X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 sel(X1, mark X2) -> mark sel(X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active zWquot(nil(), XS) -> mark nil()
                 0 + 0XS >= 1
                 active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
                 0 + 0X + 0XS + 0Y + 0YS >= 1 + 0X + 0XS + 0Y + 0YS
                 active zWquot(X1, X2) -> zWquot(active X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
                 active zWquot(X1, X2) -> zWquot(X1, active X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active zWquot(XS, nil()) -> mark nil()
                 0 + 0XS >= 1
                 active quot(0(), s Y) -> mark 0()
                 0 + 0Y >= 1
                 active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
                 0 + 0X + 0Y >= 1 + 0X + 0Y
                 active quot(X1, X2) -> quot(active X1, X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                 active quot(X1, X2) -> quot(X1, active X2)
                 0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
                 active minus(s X, s Y) -> mark minus(X, Y)
                 0 + 0X + 0Y >= 1 + 0X + 0Y
                 active minus(X1, X2) -> minus(active X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
                 active minus(X1, X2) -> minus(X1, active X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active minus(X, 0()) -> mark 0()
                 0 + 0X >= 1
                 active sel(0(), cons(X, XS)) -> mark X
                 0 + 0X + 0XS >= 1 + 0X
                 active sel(s N, cons(X, XS)) -> mark sel(N, XS)
                 0 + 0X + 0XS + 0N >= 1 + 0XS + 0N
                 active sel(X1, X2) -> sel(active X1, X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 active sel(X1, X2) -> sel(X1, active X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 active s X -> s active X
                 0 + 0X >= 1 + 0X
                 active from X -> from active X
                 0 + 0X >= 0 + 0X
                 active from X -> mark cons(X, from s X)
                 0 + 0X >= 1 + 0X
                 active cons(X1, X2) -> cons(active X1, X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                 s ok X -> ok s X
                 2 + 1X >= 2 + 1X
                 s mark X -> mark s X
                 2 + 0X >= 1 + 0X
                 from ok X -> ok from X
                 1 + 1X >= 1 + 1X
                 from mark X -> mark from X
                 1 + 0X >= 1 + 0X
                 cons(ok X1, ok X2) -> ok cons(X1, X2)
                 2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                 cons(mark X1, X2) -> mark cons(X1, X2)
                 1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
               SCCS (1):
                Scc:
                 {active# cons(X1, X2) -> active# X1,
                        active# from X -> active# X}
                
                SCC (2):
                 Strict:
                  {active# cons(X1, X2) -> active# X1,
                         active# from X -> active# X}
                 Weak:
                 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                                              from mark X -> mark from X,
                                                from ok X -> ok from X,
                                                 s mark X -> mark s X,
                                                   s ok X -> ok s X,
                                      active cons(X1, X2) -> cons(active X1, X2),
                                            active from X -> mark cons(X, from s X),
                                            active from X -> from active X,
                                               active s X -> s active X,
                                       active sel(X1, X2) -> sel(X1, active X2),
                                       active sel(X1, X2) -> sel(active X1, X2),
                             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                             active sel(0(), cons(X, XS)) -> mark X,
                                     active minus(X, 0()) -> mark 0(),
                                     active minus(X1, X2) -> minus(X1, active X2),
                                     active minus(X1, X2) -> minus(active X1, X2),
                                   active minus(s X, s Y) -> mark minus(X, Y),
                                      active quot(X1, X2) -> quot(X1, active X2),
                                      active quot(X1, X2) -> quot(active X1, X2),
                                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                                    active quot(0(), s Y) -> mark 0(),
                                 active zWquot(XS, nil()) -> mark nil(),
                                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                                    active zWquot(X1, X2) -> zWquot(active X1, X2),
                  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                                 active zWquot(nil(), XS) -> mark nil(),
                                         sel(X1, mark X2) -> mark sel(X1, X2),
                                         sel(mark X1, X2) -> mark sel(X1, X2),
                                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                                       minus(X1, mark X2) -> mark minus(X1, X2),
                                       minus(mark X1, X2) -> mark minus(X1, X2),
                                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                                        quot(X1, mark X2) -> mark quot(X1, X2),
                                        quot(mark X1, X2) -> mark quot(X1, X2),
                                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                                            proper from X -> from proper X,
                                               proper s X -> s proper X,
                                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                                               proper 0() -> ok 0(),
                                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                                             proper nil() -> ok nil(),
                                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                               top mark X -> top proper X,
                                                 top ok X -> top active X}
                 POLY:
                  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
                  Interpretation:
                   [cons](x0, x1) = x0 + x1,
                   
                   [sel](x0, x1) = 0,
                   
                   [minus](x0, x1) = x0 + 1,
                   
                   [quot](x0, x1) = 0,
                   
                   [zWquot](x0, x1) = 0,
                   
                   [mark](x0) = 0,
                   
                   [from](x0) = x0 + 1,
                   
                   [s](x0) = 0,
                   
                   [active](x0) = 0,
                   
                   [proper](x0) = 0,
                   
                   [ok](x0) = x0 + 1,
                   
                   [top](x0) = 0,
                   
                   [0] = 1,
                   
                   [nil] = 1,
                   
                   [active#](x0) = x0
                  Strict:
                   active# from X -> active# X
                   1 + 1X >= 0 + 1X
                   active# cons(X1, X2) -> active# X1
                   0 + 1X1 + 1X2 >= 0 + 1X1
                  Weak:
                   top ok X -> top active X
                   0 + 0X >= 0 + 0X
                   top mark X -> top proper X
                   0 + 0X >= 0 + 0X
                   proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   proper nil() -> ok nil()
                   0 >= 2
                   proper quot(X1, X2) -> quot(proper X1, proper X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   proper minus(X1, X2) -> minus(proper X1, proper X2)
                   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                   proper 0() -> ok 0()
                   0 >= 2
                   proper sel(X1, X2) -> sel(proper X1, proper X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   proper s X -> s proper X
                   0 + 0X >= 0 + 0X
                   proper from X -> from proper X
                   0 + 0X >= 1 + 0X
                   proper cons(X1, X2) -> cons(proper X1, proper X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
                   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   quot(ok X1, ok X2) -> ok quot(X1, X2)
                   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                   quot(mark X1, X2) -> mark quot(X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   quot(X1, mark X2) -> mark quot(X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   minus(ok X1, ok X2) -> ok minus(X1, X2)
                   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                   minus(mark X1, X2) -> mark minus(X1, X2)
                   1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2
                   minus(X1, mark X2) -> mark minus(X1, X2)
                   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   sel(ok X1, ok X2) -> ok sel(X1, X2)
                   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                   sel(mark X1, X2) -> mark sel(X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   sel(X1, mark X2) -> mark sel(X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active zWquot(nil(), XS) -> mark nil()
                   0 + 0XS >= 0
                   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
                   0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS
                   active zWquot(X1, X2) -> zWquot(active X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active zWquot(X1, X2) -> zWquot(X1, active X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active zWquot(XS, nil()) -> mark nil()
                   0 + 0XS >= 0
                   active quot(0(), s Y) -> mark 0()
                   0 + 0Y >= 0
                   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
                   0 + 0X + 0Y >= 0 + 0X + 0Y
                   active quot(X1, X2) -> quot(active X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active quot(X1, X2) -> quot(X1, active X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active minus(s X, s Y) -> mark minus(X, Y)
                   0 + 0X + 0Y >= 0 + 0X + 0Y
                   active minus(X1, X2) -> minus(active X1, X2)
                   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
                   active minus(X1, X2) -> minus(X1, active X2)
                   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                   active minus(X, 0()) -> mark 0()
                   0 + 0X >= 0
                   active sel(0(), cons(X, XS)) -> mark X
                   0 + 0X + 0XS >= 0 + 0X
                   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
                   0 + 0X + 0XS + 0N >= 0 + 0XS + 0N
                   active sel(X1, X2) -> sel(active X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active sel(X1, X2) -> sel(X1, active X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                   active s X -> s active X
                   0 + 0X >= 0 + 0X
                   active from X -> from active X
                   0 + 0X >= 1 + 0X
                   active from X -> mark cons(X, from s X)
                   0 + 0X >= 0 + 0X
                   active cons(X1, X2) -> cons(active X1, X2)
                   0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
                   s ok X -> ok s X
                   0 + 0X >= 1 + 0X
                   s mark X -> mark s X
                   0 + 0X >= 0 + 0X
                   from ok X -> ok from X
                   2 + 1X >= 2 + 1X
                   from mark X -> mark from X
                   1 + 0X >= 0 + 0X
                   cons(ok X1, ok X2) -> ok cons(X1, X2)
                   2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
                   cons(mark X1, X2) -> mark cons(X1, X2)
                   0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2
                 SCCS (1):
                  Scc:
                   {active# cons(X1, X2) -> active# X1}
                  
                  SCC (1):
                   Strict:
                    {active# cons(X1, X2) -> active# X1}
                   Weak:
                   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                                from mark X -> mark from X,
                                                  from ok X -> ok from X,
                                                   s mark X -> mark s X,
                                                     s ok X -> ok s X,
                                        active cons(X1, X2) -> cons(active X1, X2),
                                              active from X -> mark cons(X, from s X),
                                              active from X -> from active X,
                                                 active s X -> s active X,
                                         active sel(X1, X2) -> sel(X1, active X2),
                                         active sel(X1, X2) -> sel(active X1, X2),
                               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                               active sel(0(), cons(X, XS)) -> mark X,
                                       active minus(X, 0()) -> mark 0(),
                                       active minus(X1, X2) -> minus(X1, active X2),
                                       active minus(X1, X2) -> minus(active X1, X2),
                                     active minus(s X, s Y) -> mark minus(X, Y),
                                        active quot(X1, X2) -> quot(X1, active X2),
                                        active quot(X1, X2) -> quot(active X1, X2),
                                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                                      active quot(0(), s Y) -> mark 0(),
                                   active zWquot(XS, nil()) -> mark nil(),
                                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                                      active zWquot(X1, X2) -> zWquot(active X1, X2),
                    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                                   active zWquot(nil(), XS) -> mark nil(),
                                           sel(X1, mark X2) -> mark sel(X1, X2),
                                           sel(mark X1, X2) -> mark sel(X1, X2),
                                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                                         minus(X1, mark X2) -> mark minus(X1, X2),
                                         minus(mark X1, X2) -> mark minus(X1, X2),
                                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                                          quot(X1, mark X2) -> mark quot(X1, X2),
                                          quot(mark X1, X2) -> mark quot(X1, X2),
                                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                                              proper from X -> from proper X,
                                                 proper s X -> s proper X,
                                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                                 proper 0() -> ok 0(),
                                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                                               proper nil() -> ok nil(),
                                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                                 top mark X -> top proper X,
                                                   top ok X -> top active X}
                   POLY:
                    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
                    Interpretation:
                     [cons](x0, x1) = x0 + 1,
                     
                     [sel](x0, x1) = x0 + 1,
                     
                     [minus](x0, x1) = 1,
                     
                     [quot](x0, x1) = x0 + 1,
                     
                     [zWquot](x0, x1) = x0 + 1,
                     
                     [mark](x0) = x0 + 1,
                     
                     [from](x0) = x0 + 1,
                     
                     [s](x0) = x0 + 1,
                     
                     [active](x0) = x0 + 1,
                     
                     [proper](x0) = 0,
                     
                     [ok](x0) = x0 + 1,
                     
                     [top](x0) = x0 + 1,
                     
                     [0] = 1,
                     
                     [nil] = 0,
                     
                     [active#](x0) = x0
                    Strict:
                     active# cons(X1, X2) -> active# X1
                     1 + 1X1 + 0X2 >= 0 + 1X1
                    Weak:
                     top ok X -> top active X
                     2 + 1X >= 2 + 1X
                     top mark X -> top proper X
                     2 + 1X >= 1 + 0X
                     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
                     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                     proper nil() -> ok nil()
                     0 >= 1
                     proper quot(X1, X2) -> quot(proper X1, proper X2)
                     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                     proper minus(X1, X2) -> minus(proper X1, proper X2)
                     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                     proper 0() -> ok 0()
                     0 >= 2
                     proper sel(X1, X2) -> sel(proper X1, proper X2)
                     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                     proper s X -> s proper X
                     0 + 0X >= 1 + 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
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
                     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     quot(ok X1, ok X2) -> ok quot(X1, X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     quot(mark X1, X2) -> mark quot(X1, X2)
                     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     quot(X1, mark X2) -> mark quot(X1, X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     minus(ok X1, ok X2) -> ok minus(X1, X2)
                     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                     minus(mark X1, X2) -> mark minus(X1, X2)
                     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                     minus(X1, mark X2) -> mark minus(X1, X2)
                     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                     sel(ok X1, ok X2) -> ok sel(X1, X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     sel(mark X1, X2) -> mark sel(X1, X2)
                     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     sel(X1, mark X2) -> mark sel(X1, X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     active zWquot(nil(), XS) -> mark nil()
                     2 + 1XS >= 1
                     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
                     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
                     active zWquot(X1, X2) -> zWquot(active X1, X2)
                     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                     active zWquot(X1, X2) -> zWquot(X1, active X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     active zWquot(XS, nil()) -> mark nil()
                     2 + 0XS >= 1
                     active quot(0(), s Y) -> mark 0()
                     3 + 1Y >= 2
                     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
                     3 + 0X + 1Y >= 4 + 0X + 1Y
                     active quot(X1, X2) -> quot(active X1, X2)
                     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                     active quot(X1, X2) -> quot(X1, active X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     active minus(s X, s Y) -> mark minus(X, Y)
                     2 + 0X + 0Y >= 2 + 0X + 0Y
                     active minus(X1, X2) -> minus(active X1, X2)
                     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                     active minus(X1, X2) -> minus(X1, active X2)
                     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                     active minus(X, 0()) -> mark 0()
                     2 + 0X >= 2
                     active sel(0(), cons(X, XS)) -> mark X
                     3 + 1X + 0XS >= 1 + 1X
                     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
                     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
                     active sel(X1, X2) -> sel(active X1, X2)
                     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                     active sel(X1, X2) -> sel(X1, active X2)
                     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                     active s X -> s active X
                     2 + 1X >= 2 + 1X
                     active from X -> from active X
                     2 + 1X >= 2 + 1X
                     active from X -> mark cons(X, from s X)
                     2 + 1X >= 2 + 1X
                     active cons(X1, X2) -> cons(active X1, X2)
                     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                     s ok X -> ok s X
                     2 + 1X >= 2 + 1X
                     s mark X -> mark s X
                     2 + 1X >= 2 + 1X
                     from ok X -> ok from X
                     2 + 1X >= 2 + 1X
                     from mark X -> mark from X
                     2 + 1X >= 2 + 1X
                     cons(ok X1, ok X2) -> ok cons(X1, X2)
                     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                     cons(mark X1, X2) -> mark cons(X1, X2)
                     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
                   Qed
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  SCC (12):
   Strict:
    {  proper# cons(X1, X2) -> proper# X1,
       proper# cons(X1, X2) -> proper# X2,
             proper# from X -> proper# X,
                proper# s X -> proper# X,
        proper# sel(X1, X2) -> proper# X1,
        proper# sel(X1, X2) -> proper# X2,
      proper# minus(X1, X2) -> proper# X1,
      proper# minus(X1, X2) -> proper# X2,
       proper# quot(X1, X2) -> proper# X1,
       proper# quot(X1, X2) -> proper# X2,
     proper# zWquot(X1, X2) -> proper# X1,
     proper# zWquot(X1, X2) -> proper# X2}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + x1,
     
     [sel](x0, x1) = x0 + x1,
     
     [minus](x0, x1) = x0 + x1,
     
     [quot](x0, x1) = x0 + x1,
     
     [zWquot](x0, x1) = x0 + x1 + 1,
     
     [mark](x0) = x0,
     
     [from](x0) = x0,
     
     [s](x0) = x0,
     
     [active](x0) = 0,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = 0,
     
     [0] = 0,
     
     [nil] = 1,
     
     [proper#](x0) = x0
    Strict:
     proper# zWquot(X1, X2) -> proper# X2
     1 + 1X1 + 1X2 >= 0 + 1X2
     proper# zWquot(X1, X2) -> proper# X1
     1 + 1X1 + 1X2 >= 0 + 1X1
     proper# quot(X1, X2) -> proper# X2
     0 + 1X1 + 1X2 >= 0 + 1X2
     proper# quot(X1, X2) -> proper# X1
     0 + 1X1 + 1X2 >= 0 + 1X1
     proper# minus(X1, X2) -> proper# X2
     0 + 1X1 + 1X2 >= 0 + 1X2
     proper# minus(X1, X2) -> proper# X1
     0 + 1X1 + 1X2 >= 0 + 1X1
     proper# sel(X1, X2) -> proper# X2
     0 + 1X1 + 1X2 >= 0 + 1X2
     proper# sel(X1, X2) -> proper# X1
     0 + 1X1 + 1X2 >= 0 + 1X1
     proper# s X -> proper# X
     0 + 1X >= 0 + 1X
     proper# from X -> proper# X
     0 + 1X >= 0 + 1X
     proper# cons(X1, X2) -> proper# X2
     0 + 1X1 + 1X2 >= 0 + 1X2
     proper# cons(X1, X2) -> proper# X1
     0 + 1X1 + 1X2 >= 0 + 1X1
    Weak:
     top ok X -> top active X
     0 + 0X >= 0 + 0X
     top mark X -> top proper X
     0 + 0X >= 0 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 2
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 1
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 0 + 0X
     proper from X -> from proper X
     0 + 0X >= 0 + 0X
     proper cons(X1, X2) -> cons(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     0 + 0XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     0 + 0X + 0XS + 0Y + 0YS >= 1 + 1X + 1XS + 1Y + 1YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
     active zWquot(XS, nil()) -> mark nil()
     0 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     0 + 0Y >= 0
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     0 + 0X + 0Y >= 0 + 1X + 2Y
     active quot(X1, X2) -> quot(active X1, X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
     active minus(s X, s Y) -> mark minus(X, Y)
     0 + 0X + 0Y >= 0 + 1X + 1Y
     active minus(X1, X2) -> minus(active X1, X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
     active minus(X1, X2) -> minus(X1, active X2)
     0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
     active minus(X, 0()) -> mark 0()
     0 + 0X >= 0
     active sel(0(), cons(X, XS)) -> mark X
     0 + 0X + 0XS >= 0 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     0 + 0X + 0XS + 0N >= 0 + 1XS + 1N
     active sel(X1, X2) -> sel(active X1, X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
     active s X -> s active X
     0 + 0X >= 0 + 0X
     active from X -> from active X
     0 + 0X >= 0 + 0X
     active from X -> mark cons(X, from s X)
     0 + 0X >= 0 + 2X
     active cons(X1, X2) -> cons(active X1, X2)
     0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
     s ok X -> ok s X
     1 + 1X >= 1 + 1X
     s mark X -> mark s X
     0 + 1X >= 0 + 1X
     from ok X -> ok from X
     1 + 1X >= 1 + 1X
     from mark X -> mark from X
     0 + 1X >= 0 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
   SCCS (1):
    Scc:
     { proper# cons(X1, X2) -> proper# X1,
       proper# cons(X1, X2) -> proper# X2,
             proper# from X -> proper# X,
                proper# s X -> proper# X,
        proper# sel(X1, X2) -> proper# X1,
        proper# sel(X1, X2) -> proper# X2,
      proper# minus(X1, X2) -> proper# X1,
      proper# minus(X1, X2) -> proper# X2,
       proper# quot(X1, X2) -> proper# X1,
       proper# quot(X1, X2) -> proper# X2}
    
    SCC (10):
     Strict:
      { proper# cons(X1, X2) -> proper# X1,
        proper# cons(X1, X2) -> proper# X2,
              proper# from X -> proper# X,
                 proper# s X -> proper# X,
         proper# sel(X1, X2) -> proper# X1,
         proper# sel(X1, X2) -> proper# X2,
       proper# minus(X1, X2) -> proper# X1,
       proper# minus(X1, X2) -> proper# X2,
        proper# quot(X1, X2) -> proper# X1,
        proper# quot(X1, X2) -> proper# X2}
     Weak:
     {                      cons(mark X1, X2) -> mark cons(X1, X2),
                           cons(ok X1, ok X2) -> ok cons(X1, X2),
                                  from mark X -> mark from X,
                                    from ok X -> ok from X,
                                     s mark X -> mark s X,
                                       s ok X -> ok s X,
                          active cons(X1, X2) -> cons(active X1, X2),
                                active from X -> mark cons(X, from s X),
                                active from X -> from active X,
                                   active s X -> s active X,
                           active sel(X1, X2) -> sel(X1, active X2),
                           active sel(X1, X2) -> sel(active X1, X2),
                 active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                 active sel(0(), cons(X, XS)) -> mark X,
                         active minus(X, 0()) -> mark 0(),
                         active minus(X1, X2) -> minus(X1, active X2),
                         active minus(X1, X2) -> minus(active X1, X2),
                       active minus(s X, s Y) -> mark minus(X, Y),
                          active quot(X1, X2) -> quot(X1, active X2),
                          active quot(X1, X2) -> quot(active X1, X2),
                        active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                        active quot(0(), s Y) -> mark 0(),
                     active zWquot(XS, nil()) -> mark nil(),
                        active zWquot(X1, X2) -> zWquot(X1, active X2),
                        active zWquot(X1, X2) -> zWquot(active X1, X2),
      active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                     active zWquot(nil(), XS) -> mark nil(),
                             sel(X1, mark X2) -> mark sel(X1, X2),
                             sel(mark X1, X2) -> mark sel(X1, X2),
                            sel(ok X1, ok X2) -> ok sel(X1, X2),
                           minus(X1, mark X2) -> mark minus(X1, X2),
                           minus(mark X1, X2) -> mark minus(X1, X2),
                          minus(ok X1, ok X2) -> ok minus(X1, X2),
                            quot(X1, mark X2) -> mark quot(X1, X2),
                            quot(mark X1, X2) -> mark quot(X1, X2),
                           quot(ok X1, ok X2) -> ok quot(X1, X2),
                          zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                          zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                         zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                          proper cons(X1, X2) -> cons(proper X1, proper X2),
                                proper from X -> from proper X,
                                   proper s X -> s proper X,
                           proper sel(X1, X2) -> sel(proper X1, proper X2),
                                   proper 0() -> ok 0(),
                         proper minus(X1, X2) -> minus(proper X1, proper X2),
                          proper quot(X1, X2) -> quot(proper X1, proper X2),
                                 proper nil() -> ok nil(),
                        proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                   top mark X -> top proper X,
                                     top ok X -> top active X}
     POLY:
      Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
      Interpretation:
       [cons](x0, x1) = x0 + x1,
       
       [sel](x0, x1) = x0 + x1,
       
       [minus](x0, x1) = x0 + x1,
       
       [quot](x0, x1) = x0 + x1 + 1,
       
       [zWquot](x0, x1) = x0 + 1,
       
       [mark](x0) = x0,
       
       [from](x0) = x0,
       
       [s](x0) = x0,
       
       [active](x0) = 0,
       
       [proper](x0) = 0,
       
       [ok](x0) = x0 + 1,
       
       [top](x0) = 0,
       
       [0] = 0,
       
       [nil] = 1,
       
       [proper#](x0) = x0
      Strict:
       proper# quot(X1, X2) -> proper# X2
       1 + 1X1 + 1X2 >= 0 + 1X2
       proper# quot(X1, X2) -> proper# X1
       1 + 1X1 + 1X2 >= 0 + 1X1
       proper# minus(X1, X2) -> proper# X2
       0 + 1X1 + 1X2 >= 0 + 1X2
       proper# minus(X1, X2) -> proper# X1
       0 + 1X1 + 1X2 >= 0 + 1X1
       proper# sel(X1, X2) -> proper# X2
       0 + 1X1 + 1X2 >= 0 + 1X2
       proper# sel(X1, X2) -> proper# X1
       0 + 1X1 + 1X2 >= 0 + 1X1
       proper# s X -> proper# X
       0 + 1X >= 0 + 1X
       proper# from X -> proper# X
       0 + 1X >= 0 + 1X
       proper# cons(X1, X2) -> proper# X2
       0 + 1X1 + 1X2 >= 0 + 1X2
       proper# cons(X1, X2) -> proper# X1
       0 + 1X1 + 1X2 >= 0 + 1X1
      Weak:
       top ok X -> top active X
       0 + 0X >= 0 + 0X
       top mark X -> top proper X
       0 + 0X >= 0 + 0X
       proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper nil() -> ok nil()
       0 >= 2
       proper quot(X1, X2) -> quot(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       proper minus(X1, X2) -> minus(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper 0() -> ok 0()
       0 >= 1
       proper sel(X1, X2) -> sel(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       proper s X -> s proper X
       0 + 0X >= 0 + 0X
       proper from X -> from proper X
       0 + 0X >= 0 + 0X
       proper cons(X1, X2) -> cons(proper X1, proper X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
       2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
       zWquot(mark X1, X2) -> mark zWquot(X1, X2)
       1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       zWquot(X1, mark X2) -> mark zWquot(X1, X2)
       1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
       quot(ok X1, ok X2) -> ok quot(X1, X2)
       3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
       quot(mark X1, X2) -> mark quot(X1, X2)
       1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
       quot(X1, mark X2) -> mark quot(X1, X2)
       1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
       minus(ok X1, ok X2) -> ok minus(X1, X2)
       2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
       minus(mark X1, X2) -> mark minus(X1, X2)
       0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
       minus(X1, mark X2) -> mark minus(X1, X2)
       0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
       sel(ok X1, ok X2) -> ok sel(X1, X2)
       2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
       sel(mark X1, X2) -> mark sel(X1, X2)
       0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
       sel(X1, mark X2) -> mark sel(X1, X2)
       0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
       active zWquot(nil(), XS) -> mark nil()
       0 + 0XS >= 1
       active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
       0 + 0X + 0XS + 0Y + 0YS >= 2 + 1X + 0XS + 1Y + 1YS
       active zWquot(X1, X2) -> zWquot(active X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
       active zWquot(X1, X2) -> zWquot(X1, active X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
       active zWquot(XS, nil()) -> mark nil()
       0 + 0XS >= 1
       active quot(0(), s Y) -> mark 0()
       0 + 0Y >= 0
       active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
       0 + 0X + 0Y >= 1 + 1X + 2Y
       active quot(X1, X2) -> quot(active X1, X2)
       0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
       active quot(X1, X2) -> quot(X1, active X2)
       0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
       active minus(s X, s Y) -> mark minus(X, Y)
       0 + 0X + 0Y >= 0 + 1X + 1Y
       active minus(X1, X2) -> minus(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
       active minus(X1, X2) -> minus(X1, active X2)
       0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
       active minus(X, 0()) -> mark 0()
       0 + 0X >= 0
       active sel(0(), cons(X, XS)) -> mark X
       0 + 0X + 0XS >= 0 + 1X
       active sel(s N, cons(X, XS)) -> mark sel(N, XS)
       0 + 0X + 0XS + 0N >= 0 + 1XS + 1N
       active sel(X1, X2) -> sel(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
       active sel(X1, X2) -> sel(X1, active X2)
       0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
       active s X -> s active X
       0 + 0X >= 0 + 0X
       active from X -> from active X
       0 + 0X >= 0 + 0X
       active from X -> mark cons(X, from s X)
       0 + 0X >= 0 + 2X
       active cons(X1, X2) -> cons(active X1, X2)
       0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
       s ok X -> ok s X
       1 + 1X >= 1 + 1X
       s mark X -> mark s X
       0 + 1X >= 0 + 1X
       from ok X -> ok from X
       1 + 1X >= 1 + 1X
       from mark X -> mark from X
       0 + 1X >= 0 + 1X
       cons(ok X1, ok X2) -> ok cons(X1, X2)
       2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
       cons(mark X1, X2) -> mark cons(X1, X2)
       0 + 1X1 + 1X2 >= 0 + 1X1 + 1X2
     SCCS (1):
      Scc:
       { proper# cons(X1, X2) -> proper# X1,
         proper# cons(X1, X2) -> proper# X2,
               proper# from X -> proper# X,
                  proper# s X -> proper# X,
          proper# sel(X1, X2) -> proper# X1,
          proper# sel(X1, X2) -> proper# X2,
        proper# minus(X1, X2) -> proper# X1,
        proper# minus(X1, X2) -> proper# X2}
      
      SCC (8):
       Strict:
        { proper# cons(X1, X2) -> proper# X1,
          proper# cons(X1, X2) -> proper# X2,
                proper# from X -> proper# X,
                   proper# s X -> proper# X,
           proper# sel(X1, X2) -> proper# X1,
           proper# sel(X1, X2) -> proper# X2,
         proper# minus(X1, X2) -> proper# X1,
         proper# minus(X1, X2) -> proper# X2}
       Weak:
       {                      cons(mark X1, X2) -> mark cons(X1, X2),
                             cons(ok X1, ok X2) -> ok cons(X1, X2),
                                    from mark X -> mark from X,
                                      from ok X -> ok from X,
                                       s mark X -> mark s X,
                                         s ok X -> ok s X,
                            active cons(X1, X2) -> cons(active X1, X2),
                                  active from X -> mark cons(X, from s X),
                                  active from X -> from active X,
                                     active s X -> s active X,
                             active sel(X1, X2) -> sel(X1, active X2),
                             active sel(X1, X2) -> sel(active X1, X2),
                   active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                   active sel(0(), cons(X, XS)) -> mark X,
                           active minus(X, 0()) -> mark 0(),
                           active minus(X1, X2) -> minus(X1, active X2),
                           active minus(X1, X2) -> minus(active X1, X2),
                         active minus(s X, s Y) -> mark minus(X, Y),
                            active quot(X1, X2) -> quot(X1, active X2),
                            active quot(X1, X2) -> quot(active X1, X2),
                          active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                          active quot(0(), s Y) -> mark 0(),
                       active zWquot(XS, nil()) -> mark nil(),
                          active zWquot(X1, X2) -> zWquot(X1, active X2),
                          active zWquot(X1, X2) -> zWquot(active X1, X2),
        active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                       active zWquot(nil(), XS) -> mark nil(),
                               sel(X1, mark X2) -> mark sel(X1, X2),
                               sel(mark X1, X2) -> mark sel(X1, X2),
                              sel(ok X1, ok X2) -> ok sel(X1, X2),
                             minus(X1, mark X2) -> mark minus(X1, X2),
                             minus(mark X1, X2) -> mark minus(X1, X2),
                            minus(ok X1, ok X2) -> ok minus(X1, X2),
                              quot(X1, mark X2) -> mark quot(X1, X2),
                              quot(mark X1, X2) -> mark quot(X1, X2),
                             quot(ok X1, ok X2) -> ok quot(X1, X2),
                            zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                            zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                           zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                            proper cons(X1, X2) -> cons(proper X1, proper X2),
                                  proper from X -> from proper X,
                                     proper s X -> s proper X,
                             proper sel(X1, X2) -> sel(proper X1, proper X2),
                                     proper 0() -> ok 0(),
                           proper minus(X1, X2) -> minus(proper X1, proper X2),
                            proper quot(X1, X2) -> quot(proper X1, proper X2),
                                   proper nil() -> ok nil(),
                          proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                     top mark X -> top proper X,
                                       top ok X -> top active X}
       POLY:
        Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
        Interpretation:
         [cons](x0, x1) = x0 + x1,
         
         [sel](x0, x1) = x0 + x1,
         
         [minus](x0, x1) = x0 + x1 + 1,
         
         [quot](x0, x1) = 0,
         
         [zWquot](x0, x1) = x0 + 1,
         
         [mark](x0) = x0 + 1,
         
         [from](x0) = x0,
         
         [s](x0) = x0,
         
         [active](x0) = 0,
         
         [proper](x0) = 0,
         
         [ok](x0) = x0 + 1,
         
         [top](x0) = 0,
         
         [0] = 0,
         
         [nil] = 1,
         
         [proper#](x0) = x0
        Strict:
         proper# minus(X1, X2) -> proper# X2
         1 + 1X1 + 1X2 >= 0 + 1X2
         proper# minus(X1, X2) -> proper# X1
         1 + 1X1 + 1X2 >= 0 + 1X1
         proper# sel(X1, X2) -> proper# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         proper# sel(X1, X2) -> proper# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
         proper# s X -> proper# X
         0 + 1X >= 0 + 1X
         proper# from X -> proper# X
         0 + 1X >= 0 + 1X
         proper# cons(X1, X2) -> proper# X2
         0 + 1X1 + 1X2 >= 0 + 1X2
         proper# cons(X1, X2) -> proper# X1
         0 + 1X1 + 1X2 >= 0 + 1X1
        Weak:
         top ok X -> top active X
         0 + 0X >= 0 + 0X
         top mark X -> top proper X
         0 + 0X >= 0 + 0X
         proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper nil() -> ok nil()
         0 >= 2
         proper quot(X1, X2) -> quot(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         proper minus(X1, X2) -> minus(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         proper 0() -> ok 0()
         0 >= 1
         proper sel(X1, X2) -> sel(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         proper s X -> s proper X
         0 + 0X >= 0 + 0X
         proper from X -> from proper X
         0 + 0X >= 0 + 0X
         proper cons(X1, X2) -> cons(proper X1, proper X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         zWquot(mark X1, X2) -> mark zWquot(X1, X2)
         1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         zWquot(X1, mark X2) -> mark zWquot(X1, X2)
         2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
         quot(ok X1, ok X2) -> ok quot(X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         quot(mark X1, X2) -> mark quot(X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         quot(X1, mark X2) -> mark quot(X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         minus(ok X1, ok X2) -> ok minus(X1, X2)
         3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         minus(mark X1, X2) -> mark minus(X1, X2)
         2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         minus(X1, mark X2) -> mark minus(X1, X2)
         2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
         sel(ok X1, ok X2) -> ok sel(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         sel(mark X1, X2) -> mark sel(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         sel(X1, mark X2) -> mark sel(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         active zWquot(nil(), XS) -> mark nil()
         0 + 0XS >= 2
         active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
         0 + 0X + 0XS + 0Y + 0YS >= 2 + 0X + 0XS + 0Y + 1YS
         active zWquot(X1, X2) -> zWquot(active X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
         active zWquot(X1, X2) -> zWquot(X1, active X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
         active zWquot(XS, nil()) -> mark nil()
         0 + 0XS >= 2
         active quot(0(), s Y) -> mark 0()
         0 + 0Y >= 1
         active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
         0 + 0X + 0Y >= 1 + 0X + 0Y
         active quot(X1, X2) -> quot(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         active quot(X1, X2) -> quot(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
         active minus(s X, s Y) -> mark minus(X, Y)
         0 + 0X + 0Y >= 2 + 1X + 1Y
         active minus(X1, X2) -> minus(active X1, X2)
         0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
         active minus(X1, X2) -> minus(X1, active X2)
         0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
         active minus(X, 0()) -> mark 0()
         0 + 0X >= 1
         active sel(0(), cons(X, XS)) -> mark X
         0 + 0X + 0XS >= 1 + 1X
         active sel(s N, cons(X, XS)) -> mark sel(N, XS)
         0 + 0X + 0XS + 0N >= 1 + 1XS + 1N
         active sel(X1, X2) -> sel(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         active sel(X1, X2) -> sel(X1, active X2)
         0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
         active s X -> s active X
         0 + 0X >= 0 + 0X
         active from X -> from active X
         0 + 0X >= 0 + 0X
         active from X -> mark cons(X, from s X)
         0 + 0X >= 1 + 2X
         active cons(X1, X2) -> cons(active X1, X2)
         0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
         s ok X -> ok s X
         1 + 1X >= 1 + 1X
         s mark X -> mark s X
         1 + 1X >= 1 + 1X
         from ok X -> ok from X
         1 + 1X >= 1 + 1X
         from mark X -> mark from X
         1 + 1X >= 1 + 1X
         cons(ok X1, ok X2) -> ok cons(X1, X2)
         2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
         cons(mark X1, X2) -> mark cons(X1, X2)
         1 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
       SCCS (1):
        Scc:
         {proper# cons(X1, X2) -> proper# X1,
          proper# cons(X1, X2) -> proper# X2,
                proper# from X -> proper# X,
                   proper# s X -> proper# X,
           proper# sel(X1, X2) -> proper# X1,
           proper# sel(X1, X2) -> proper# X2}
        
        SCC (6):
         Strict:
          {proper# cons(X1, X2) -> proper# X1,
           proper# cons(X1, X2) -> proper# X2,
                 proper# from X -> proper# X,
                    proper# s X -> proper# X,
            proper# sel(X1, X2) -> proper# X1,
            proper# sel(X1, X2) -> proper# X2}
         Weak:
         {                      cons(mark X1, X2) -> mark cons(X1, X2),
                               cons(ok X1, ok X2) -> ok cons(X1, X2),
                                      from mark X -> mark from X,
                                        from ok X -> ok from X,
                                         s mark X -> mark s X,
                                           s ok X -> ok s X,
                              active cons(X1, X2) -> cons(active X1, X2),
                                    active from X -> mark cons(X, from s X),
                                    active from X -> from active X,
                                       active s X -> s active X,
                               active sel(X1, X2) -> sel(X1, active X2),
                               active sel(X1, X2) -> sel(active X1, X2),
                     active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                     active sel(0(), cons(X, XS)) -> mark X,
                             active minus(X, 0()) -> mark 0(),
                             active minus(X1, X2) -> minus(X1, active X2),
                             active minus(X1, X2) -> minus(active X1, X2),
                           active minus(s X, s Y) -> mark minus(X, Y),
                              active quot(X1, X2) -> quot(X1, active X2),
                              active quot(X1, X2) -> quot(active X1, X2),
                            active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                            active quot(0(), s Y) -> mark 0(),
                         active zWquot(XS, nil()) -> mark nil(),
                            active zWquot(X1, X2) -> zWquot(X1, active X2),
                            active zWquot(X1, X2) -> zWquot(active X1, X2),
          active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                         active zWquot(nil(), XS) -> mark nil(),
                                 sel(X1, mark X2) -> mark sel(X1, X2),
                                 sel(mark X1, X2) -> mark sel(X1, X2),
                                sel(ok X1, ok X2) -> ok sel(X1, X2),
                               minus(X1, mark X2) -> mark minus(X1, X2),
                               minus(mark X1, X2) -> mark minus(X1, X2),
                              minus(ok X1, ok X2) -> ok minus(X1, X2),
                                quot(X1, mark X2) -> mark quot(X1, X2),
                                quot(mark X1, X2) -> mark quot(X1, X2),
                               quot(ok X1, ok X2) -> ok quot(X1, X2),
                              zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                              zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                             zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                              proper cons(X1, X2) -> cons(proper X1, proper X2),
                                    proper from X -> from proper X,
                                       proper s X -> s proper X,
                               proper sel(X1, X2) -> sel(proper X1, proper X2),
                                       proper 0() -> ok 0(),
                             proper minus(X1, X2) -> minus(proper X1, proper X2),
                              proper quot(X1, X2) -> quot(proper X1, proper X2),
                                     proper nil() -> ok nil(),
                            proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                       top mark X -> top proper X,
                                         top ok X -> top active X}
         POLY:
          Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
          Interpretation:
           [cons](x0, x1) = x0 + x1,
           
           [sel](x0, x1) = x0 + x1 + 1,
           
           [minus](x0, x1) = x0 + 1,
           
           [quot](x0, x1) = x0 + 1,
           
           [zWquot](x0, x1) = x0 + 1,
           
           [mark](x0) = 1,
           
           [from](x0) = x0,
           
           [s](x0) = x0,
           
           [active](x0) = 0,
           
           [proper](x0) = 0,
           
           [ok](x0) = x0 + 1,
           
           [top](x0) = 0,
           
           [0] = 1,
           
           [nil] = 1,
           
           [proper#](x0) = x0
          Strict:
           proper# sel(X1, X2) -> proper# X2
           1 + 1X1 + 1X2 >= 0 + 1X2
           proper# sel(X1, X2) -> proper# X1
           1 + 1X1 + 1X2 >= 0 + 1X1
           proper# s X -> proper# X
           0 + 1X >= 0 + 1X
           proper# from X -> proper# X
           0 + 1X >= 0 + 1X
           proper# cons(X1, X2) -> proper# X2
           0 + 1X1 + 1X2 >= 0 + 1X2
           proper# cons(X1, X2) -> proper# X1
           0 + 1X1 + 1X2 >= 0 + 1X1
          Weak:
           top ok X -> top active X
           0 + 0X >= 0 + 0X
           top mark X -> top proper X
           0 + 0X >= 0 + 0X
           proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper nil() -> ok nil()
           0 >= 2
           proper quot(X1, X2) -> quot(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper minus(X1, X2) -> minus(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper 0() -> ok 0()
           0 >= 2
           proper sel(X1, X2) -> sel(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           proper s X -> s proper X
           0 + 0X >= 0 + 0X
           proper from X -> from proper X
           0 + 0X >= 0 + 0X
           proper cons(X1, X2) -> cons(proper X1, proper X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
           zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           zWquot(mark X1, X2) -> mark zWquot(X1, X2)
           1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
           zWquot(X1, mark X2) -> mark zWquot(X1, X2)
           2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           quot(ok X1, ok X2) -> ok quot(X1, X2)
           2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
           quot(mark X1, X2) -> mark quot(X1, X2)
           2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           quot(X1, mark X2) -> mark quot(X1, X2)
           1 + 1X1 + 0X2 >= 1 + 0X1 + 0X2
           minus(ok X1, ok X2) -> ok minus(X1, X2)
           2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
           minus(mark X1, X2) -> mark minus(X1, X2)
           1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
           minus(X1, mark X2) -> mark minus(X1, X2)
           2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           sel(ok X1, ok X2) -> ok sel(X1, X2)
           3 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
           sel(mark X1, X2) -> mark sel(X1, X2)
           2 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
           sel(X1, mark X2) -> mark sel(X1, X2)
           2 + 1X1 + 0X2 >= 1 + 0X1 + 0X2
           active zWquot(nil(), XS) -> mark nil()
           0 + 0XS >= 1
           active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
           0 + 0X + 0XS + 0Y + 0YS >= 1 + 0X + 0XS + 0Y + 0YS
           active zWquot(X1, X2) -> zWquot(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
           active zWquot(X1, X2) -> zWquot(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           active zWquot(XS, nil()) -> mark nil()
           0 + 0XS >= 1
           active quot(0(), s Y) -> mark 0()
           0 + 0Y >= 1
           active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
           0 + 0X + 0Y >= 1 + 0X + 0Y
           active quot(X1, X2) -> quot(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           active quot(X1, X2) -> quot(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
           active minus(s X, s Y) -> mark minus(X, Y)
           0 + 0X + 0Y >= 1 + 0X + 0Y
           active minus(X1, X2) -> minus(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
           active minus(X1, X2) -> minus(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
           active minus(X, 0()) -> mark 0()
           0 + 0X >= 1
           active sel(0(), cons(X, XS)) -> mark X
           0 + 0X + 0XS >= 1 + 0X
           active sel(s N, cons(X, XS)) -> mark sel(N, XS)
           0 + 0X + 0XS + 0N >= 1 + 0XS + 0N
           active sel(X1, X2) -> sel(active X1, X2)
           0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
           active sel(X1, X2) -> sel(X1, active X2)
           0 + 0X1 + 0X2 >= 1 + 1X1 + 0X2
           active s X -> s active X
           0 + 0X >= 0 + 0X
           active from X -> from active X
           0 + 0X >= 0 + 0X
           active from X -> mark cons(X, from s X)
           0 + 0X >= 1 + 0X
           active cons(X1, X2) -> cons(active X1, X2)
           0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
           s ok X -> ok s X
           1 + 1X >= 1 + 1X
           s mark X -> mark s X
           1 + 0X >= 1 + 0X
           from ok X -> ok from X
           1 + 1X >= 1 + 1X
           from mark X -> mark from X
           1 + 0X >= 1 + 0X
           cons(ok X1, ok X2) -> ok cons(X1, X2)
           2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
           cons(mark X1, X2) -> mark cons(X1, X2)
           1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
         SCCS (1):
          Scc:
           {proper# cons(X1, X2) -> proper# X1,
            proper# cons(X1, X2) -> proper# X2,
                  proper# from X -> proper# X,
                     proper# s X -> proper# X}
          
          SCC (4):
           Strict:
            {proper# cons(X1, X2) -> proper# X1,
             proper# cons(X1, X2) -> proper# X2,
                   proper# from X -> proper# X,
                      proper# s X -> proper# X}
           Weak:
           {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                 cons(ok X1, ok X2) -> ok cons(X1, X2),
                                        from mark X -> mark from X,
                                          from ok X -> ok from X,
                                           s mark X -> mark s X,
                                             s ok X -> ok s X,
                                active cons(X1, X2) -> cons(active X1, X2),
                                      active from X -> mark cons(X, from s X),
                                      active from X -> from active X,
                                         active s X -> s active X,
                                 active sel(X1, X2) -> sel(X1, active X2),
                                 active sel(X1, X2) -> sel(active X1, X2),
                       active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                       active sel(0(), cons(X, XS)) -> mark X,
                               active minus(X, 0()) -> mark 0(),
                               active minus(X1, X2) -> minus(X1, active X2),
                               active minus(X1, X2) -> minus(active X1, X2),
                             active minus(s X, s Y) -> mark minus(X, Y),
                                active quot(X1, X2) -> quot(X1, active X2),
                                active quot(X1, X2) -> quot(active X1, X2),
                              active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                              active quot(0(), s Y) -> mark 0(),
                           active zWquot(XS, nil()) -> mark nil(),
                              active zWquot(X1, X2) -> zWquot(X1, active X2),
                              active zWquot(X1, X2) -> zWquot(active X1, X2),
            active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                           active zWquot(nil(), XS) -> mark nil(),
                                   sel(X1, mark X2) -> mark sel(X1, X2),
                                   sel(mark X1, X2) -> mark sel(X1, X2),
                                  sel(ok X1, ok X2) -> ok sel(X1, X2),
                                 minus(X1, mark X2) -> mark minus(X1, X2),
                                 minus(mark X1, X2) -> mark minus(X1, X2),
                                minus(ok X1, ok X2) -> ok minus(X1, X2),
                                  quot(X1, mark X2) -> mark quot(X1, X2),
                                  quot(mark X1, X2) -> mark quot(X1, X2),
                                 quot(ok X1, ok X2) -> ok quot(X1, X2),
                                zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                               zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                proper cons(X1, X2) -> cons(proper X1, proper X2),
                                      proper from X -> from proper X,
                                         proper s X -> s proper X,
                                 proper sel(X1, X2) -> sel(proper X1, proper X2),
                                         proper 0() -> ok 0(),
                               proper minus(X1, X2) -> minus(proper X1, proper X2),
                                proper quot(X1, X2) -> quot(proper X1, proper X2),
                                       proper nil() -> ok nil(),
                              proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                         top mark X -> top proper X,
                                           top ok X -> top active X}
           POLY:
            Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
            Interpretation:
             [cons](x0, x1) = x0 + x1,
             
             [sel](x0, x1) = 0,
             
             [minus](x0, x1) = x0 + 1,
             
             [quot](x0, x1) = x0 + x1,
             
             [zWquot](x0, x1) = x0 + 1,
             
             [mark](x0) = 1,
             
             [from](x0) = x0,
             
             [s](x0) = x0 + 1,
             
             [active](x0) = 0,
             
             [proper](x0) = 0,
             
             [ok](x0) = x0 + 1,
             
             [top](x0) = 0,
             
             [0] = 1,
             
             [nil] = 1,
             
             [proper#](x0) = x0
            Strict:
             proper# s X -> proper# X
             1 + 1X >= 0 + 1X
             proper# from X -> proper# X
             0 + 1X >= 0 + 1X
             proper# cons(X1, X2) -> proper# X2
             0 + 1X1 + 1X2 >= 0 + 1X2
             proper# cons(X1, X2) -> proper# X1
             0 + 1X1 + 1X2 >= 0 + 1X1
            Weak:
             top ok X -> top active X
             0 + 0X >= 0 + 0X
             top mark X -> top proper X
             0 + 0X >= 0 + 0X
             proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             proper nil() -> ok nil()
             0 >= 2
             proper quot(X1, X2) -> quot(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper minus(X1, X2) -> minus(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             proper 0() -> ok 0()
             0 >= 2
             proper sel(X1, X2) -> sel(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             proper s X -> s proper X
             0 + 0X >= 1 + 0X
             proper from X -> from proper X
             0 + 0X >= 0 + 0X
             proper cons(X1, X2) -> cons(proper X1, proper X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
             2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
             zWquot(mark X1, X2) -> mark zWquot(X1, X2)
             1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
             zWquot(X1, mark X2) -> mark zWquot(X1, X2)
             2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             quot(ok X1, ok X2) -> ok quot(X1, X2)
             2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             quot(mark X1, X2) -> mark quot(X1, X2)
             1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
             quot(X1, mark X2) -> mark quot(X1, X2)
             1 + 1X1 + 0X2 >= 1 + 0X1 + 0X2
             minus(ok X1, ok X2) -> ok minus(X1, X2)
             2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
             minus(mark X1, X2) -> mark minus(X1, X2)
             1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
             minus(X1, mark X2) -> mark minus(X1, X2)
             2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             sel(ok X1, ok X2) -> ok sel(X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             sel(mark X1, X2) -> mark sel(X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             sel(X1, mark X2) -> mark sel(X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             active zWquot(nil(), XS) -> mark nil()
             0 + 0XS >= 1
             active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
             0 + 0X + 0XS + 0Y + 0YS >= 1 + 0X + 0XS + 0Y + 0YS
             active zWquot(X1, X2) -> zWquot(active X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
             active zWquot(X1, X2) -> zWquot(X1, active X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             active zWquot(XS, nil()) -> mark nil()
             0 + 0XS >= 1
             active quot(0(), s Y) -> mark 0()
             0 + 0Y >= 1
             active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
             0 + 0X + 0Y >= 1 + 0X + 0Y
             active quot(X1, X2) -> quot(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             active quot(X1, X2) -> quot(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 1X1 + 0X2
             active minus(s X, s Y) -> mark minus(X, Y)
             0 + 0X + 0Y >= 1 + 0X + 0Y
             active minus(X1, X2) -> minus(active X1, X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
             active minus(X1, X2) -> minus(X1, active X2)
             0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
             active minus(X, 0()) -> mark 0()
             0 + 0X >= 1
             active sel(0(), cons(X, XS)) -> mark X
             0 + 0X + 0XS >= 1 + 0X
             active sel(s N, cons(X, XS)) -> mark sel(N, XS)
             0 + 0X + 0XS + 0N >= 1 + 0XS + 0N
             active sel(X1, X2) -> sel(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             active sel(X1, X2) -> sel(X1, active X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
             active s X -> s active X
             0 + 0X >= 1 + 0X
             active from X -> from active X
             0 + 0X >= 0 + 0X
             active from X -> mark cons(X, from s X)
             0 + 0X >= 1 + 0X
             active cons(X1, X2) -> cons(active X1, X2)
             0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
             s ok X -> ok s X
             2 + 1X >= 2 + 1X
             s mark X -> mark s X
             2 + 0X >= 1 + 0X
             from ok X -> ok from X
             1 + 1X >= 1 + 1X
             from mark X -> mark from X
             1 + 0X >= 1 + 0X
             cons(ok X1, ok X2) -> ok cons(X1, X2)
             2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
             cons(mark X1, X2) -> mark cons(X1, X2)
             1 + 0X1 + 1X2 >= 1 + 0X1 + 0X2
           SCCS (1):
            Scc:
             {proper# cons(X1, X2) -> proper# X1,
              proper# cons(X1, X2) -> proper# X2,
                    proper# from X -> proper# X}
            
            SCC (3):
             Strict:
              {proper# cons(X1, X2) -> proper# X1,
               proper# cons(X1, X2) -> proper# X2,
                     proper# from X -> proper# X}
             Weak:
             {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                   cons(ok X1, ok X2) -> ok cons(X1, X2),
                                          from mark X -> mark from X,
                                            from ok X -> ok from X,
                                             s mark X -> mark s X,
                                               s ok X -> ok s X,
                                  active cons(X1, X2) -> cons(active X1, X2),
                                        active from X -> mark cons(X, from s X),
                                        active from X -> from active X,
                                           active s X -> s active X,
                                   active sel(X1, X2) -> sel(X1, active X2),
                                   active sel(X1, X2) -> sel(active X1, X2),
                         active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                         active sel(0(), cons(X, XS)) -> mark X,
                                 active minus(X, 0()) -> mark 0(),
                                 active minus(X1, X2) -> minus(X1, active X2),
                                 active minus(X1, X2) -> minus(active X1, X2),
                               active minus(s X, s Y) -> mark minus(X, Y),
                                  active quot(X1, X2) -> quot(X1, active X2),
                                  active quot(X1, X2) -> quot(active X1, X2),
                                active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                                active quot(0(), s Y) -> mark 0(),
                             active zWquot(XS, nil()) -> mark nil(),
                                active zWquot(X1, X2) -> zWquot(X1, active X2),
                                active zWquot(X1, X2) -> zWquot(active X1, X2),
              active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                             active zWquot(nil(), XS) -> mark nil(),
                                     sel(X1, mark X2) -> mark sel(X1, X2),
                                     sel(mark X1, X2) -> mark sel(X1, X2),
                                    sel(ok X1, ok X2) -> ok sel(X1, X2),
                                   minus(X1, mark X2) -> mark minus(X1, X2),
                                   minus(mark X1, X2) -> mark minus(X1, X2),
                                  minus(ok X1, ok X2) -> ok minus(X1, X2),
                                    quot(X1, mark X2) -> mark quot(X1, X2),
                                    quot(mark X1, X2) -> mark quot(X1, X2),
                                   quot(ok X1, ok X2) -> ok quot(X1, X2),
                                  zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                  zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                                 zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                  proper cons(X1, X2) -> cons(proper X1, proper X2),
                                        proper from X -> from proper X,
                                           proper s X -> s proper X,
                                   proper sel(X1, X2) -> sel(proper X1, proper X2),
                                           proper 0() -> ok 0(),
                                 proper minus(X1, X2) -> minus(proper X1, proper X2),
                                  proper quot(X1, X2) -> quot(proper X1, proper X2),
                                         proper nil() -> ok nil(),
                                proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                           top mark X -> top proper X,
                                             top ok X -> top active X}
             POLY:
              Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
              Interpretation:
               [cons](x0, x1) = x0 + x1,
               
               [sel](x0, x1) = 0,
               
               [minus](x0, x1) = x0 + 1,
               
               [quot](x0, x1) = x0,
               
               [zWquot](x0, x1) = 0,
               
               [mark](x0) = 0,
               
               [from](x0) = x0 + 1,
               
               [s](x0) = 0,
               
               [active](x0) = 0,
               
               [proper](x0) = 0,
               
               [ok](x0) = x0 + 1,
               
               [top](x0) = 0,
               
               [0] = 1,
               
               [nil] = 1,
               
               [proper#](x0) = x0
              Strict:
               proper# from X -> proper# X
               1 + 1X >= 0 + 1X
               proper# cons(X1, X2) -> proper# X2
               0 + 1X1 + 1X2 >= 0 + 1X2
               proper# cons(X1, X2) -> proper# X1
               0 + 1X1 + 1X2 >= 0 + 1X1
              Weak:
               top ok X -> top active X
               0 + 0X >= 0 + 0X
               top mark X -> top proper X
               0 + 0X >= 0 + 0X
               proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               proper nil() -> ok nil()
               0 >= 2
               proper quot(X1, X2) -> quot(proper X1, proper X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               proper minus(X1, X2) -> minus(proper X1, proper X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               proper 0() -> ok 0()
               0 >= 2
               proper sel(X1, X2) -> sel(proper X1, proper X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               proper s X -> s proper X
               0 + 0X >= 0 + 0X
               proper from X -> from proper X
               0 + 0X >= 1 + 0X
               proper cons(X1, X2) -> cons(proper X1, proper X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               zWquot(mark X1, X2) -> mark zWquot(X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               zWquot(X1, mark X2) -> mark zWquot(X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               quot(ok X1, ok X2) -> ok quot(X1, X2)
               1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
               quot(mark X1, X2) -> mark quot(X1, X2)
               0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2
               quot(X1, mark X2) -> mark quot(X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               minus(ok X1, ok X2) -> ok minus(X1, X2)
               2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
               minus(mark X1, X2) -> mark minus(X1, X2)
               1 + 0X1 + 1X2 >= 0 + 0X1 + 0X2
               minus(X1, mark X2) -> mark minus(X1, X2)
               1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               sel(ok X1, ok X2) -> ok sel(X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               sel(mark X1, X2) -> mark sel(X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               sel(X1, mark X2) -> mark sel(X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               active zWquot(nil(), XS) -> mark nil()
               0 + 0XS >= 0
               active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
               0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS
               active zWquot(X1, X2) -> zWquot(active X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               active zWquot(X1, X2) -> zWquot(X1, active X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               active zWquot(XS, nil()) -> mark nil()
               0 + 0XS >= 0
               active quot(0(), s Y) -> mark 0()
               0 + 0Y >= 0
               active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
               0 + 0X + 0Y >= 0 + 0X + 0Y
               active quot(X1, X2) -> quot(active X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
               active quot(X1, X2) -> quot(X1, active X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               active minus(s X, s Y) -> mark minus(X, Y)
               0 + 0X + 0Y >= 0 + 0X + 0Y
               active minus(X1, X2) -> minus(active X1, X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
               active minus(X1, X2) -> minus(X1, active X2)
               0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
               active minus(X, 0()) -> mark 0()
               0 + 0X >= 0
               active sel(0(), cons(X, XS)) -> mark X
               0 + 0X + 0XS >= 0 + 0X
               active sel(s N, cons(X, XS)) -> mark sel(N, XS)
               0 + 0X + 0XS + 0N >= 0 + 0XS + 0N
               active sel(X1, X2) -> sel(active X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               active sel(X1, X2) -> sel(X1, active X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
               active s X -> s active X
               0 + 0X >= 0 + 0X
               active from X -> from active X
               0 + 0X >= 1 + 0X
               active from X -> mark cons(X, from s X)
               0 + 0X >= 0 + 0X
               active cons(X1, X2) -> cons(active X1, X2)
               0 + 0X1 + 0X2 >= 0 + 0X1 + 1X2
               s ok X -> ok s X
               0 + 0X >= 1 + 0X
               s mark X -> mark s X
               0 + 0X >= 0 + 0X
               from ok X -> ok from X
               2 + 1X >= 2 + 1X
               from mark X -> mark from X
               1 + 0X >= 0 + 0X
               cons(ok X1, ok X2) -> ok cons(X1, X2)
               2 + 1X1 + 1X2 >= 1 + 1X1 + 1X2
               cons(mark X1, X2) -> mark cons(X1, X2)
               0 + 0X1 + 1X2 >= 0 + 0X1 + 0X2
             SCCS (1):
              Scc:
               {proper# cons(X1, X2) -> proper# X1,
                proper# cons(X1, X2) -> proper# X2}
              
              SCC (2):
               Strict:
                {proper# cons(X1, X2) -> proper# X1,
                 proper# cons(X1, X2) -> proper# X2}
               Weak:
               {                      cons(mark X1, X2) -> mark cons(X1, X2),
                                     cons(ok X1, ok X2) -> ok cons(X1, X2),
                                            from mark X -> mark from X,
                                              from ok X -> ok from X,
                                               s mark X -> mark s X,
                                                 s ok X -> ok s X,
                                    active cons(X1, X2) -> cons(active X1, X2),
                                          active from X -> mark cons(X, from s X),
                                          active from X -> from active X,
                                             active s X -> s active X,
                                     active sel(X1, X2) -> sel(X1, active X2),
                                     active sel(X1, X2) -> sel(active X1, X2),
                           active sel(s N, cons(X, XS)) -> mark sel(N, XS),
                           active sel(0(), cons(X, XS)) -> mark X,
                                   active minus(X, 0()) -> mark 0(),
                                   active minus(X1, X2) -> minus(X1, active X2),
                                   active minus(X1, X2) -> minus(active X1, X2),
                                 active minus(s X, s Y) -> mark minus(X, Y),
                                    active quot(X1, X2) -> quot(X1, active X2),
                                    active quot(X1, X2) -> quot(active X1, X2),
                                  active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                                  active quot(0(), s Y) -> mark 0(),
                               active zWquot(XS, nil()) -> mark nil(),
                                  active zWquot(X1, X2) -> zWquot(X1, active X2),
                                  active zWquot(X1, X2) -> zWquot(active X1, X2),
                active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                               active zWquot(nil(), XS) -> mark nil(),
                                       sel(X1, mark X2) -> mark sel(X1, X2),
                                       sel(mark X1, X2) -> mark sel(X1, X2),
                                      sel(ok X1, ok X2) -> ok sel(X1, X2),
                                     minus(X1, mark X2) -> mark minus(X1, X2),
                                     minus(mark X1, X2) -> mark minus(X1, X2),
                                    minus(ok X1, ok X2) -> ok minus(X1, X2),
                                      quot(X1, mark X2) -> mark quot(X1, X2),
                                      quot(mark X1, X2) -> mark quot(X1, X2),
                                     quot(ok X1, ok X2) -> ok quot(X1, X2),
                                    zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                                    zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                                   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                                    proper cons(X1, X2) -> cons(proper X1, proper X2),
                                          proper from X -> from proper X,
                                             proper s X -> s proper X,
                                     proper sel(X1, X2) -> sel(proper X1, proper X2),
                                             proper 0() -> ok 0(),
                                   proper minus(X1, X2) -> minus(proper X1, proper X2),
                                    proper quot(X1, X2) -> quot(proper X1, proper X2),
                                           proper nil() -> ok nil(),
                                  proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                             top mark X -> top proper X,
                                               top ok X -> top active X}
               POLY:
                Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
                Interpretation:
                 [cons](x0, x1) = x0 + x1 + 1,
                 
                 [sel](x0, x1) = x0 + 1,
                 
                 [minus](x0, x1) = 1,
                 
                 [quot](x0, x1) = 0,
                 
                 [zWquot](x0, x1) = 1,
                 
                 [mark](x0) = x0 + 1,
                 
                 [from](x0) = x0 + 1,
                 
                 [s](x0) = 0,
                 
                 [active](x0) = x0 + 1,
                 
                 [proper](x0) = 0,
                 
                 [ok](x0) = 0,
                 
                 [top](x0) = 0,
                 
                 [0] = 1,
                 
                 [nil] = 1,
                 
                 [proper#](x0) = x0 + 1
                Strict:
                 proper# cons(X1, X2) -> proper# X2
                 2 + 1X1 + 1X2 >= 1 + 1X2
                 proper# cons(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 zWquot(X1, X2) -> zWquot(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 proper nil() -> ok nil()
                 0 >= 0
                 proper quot(X1, X2) -> quot(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 proper minus(X1, X2) -> minus(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 proper 0() -> ok 0()
                 0 >= 0
                 proper sel(X1, X2) -> sel(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 proper s X -> s proper X
                 0 + 0X >= 0 + 0X
                 proper from X -> from proper X
                 0 + 0X >= 1 + 0X
                 proper cons(X1, X2) -> cons(proper X1, proper X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
                 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 zWquot(mark X1, X2) -> mark zWquot(X1, X2)
                 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                 zWquot(X1, mark X2) -> mark zWquot(X1, X2)
                 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                 quot(ok X1, ok X2) -> ok quot(X1, X2)
                 0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 quot(mark X1, X2) -> mark quot(X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 quot(X1, mark X2) -> mark quot(X1, X2)
                 0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 minus(ok X1, ok X2) -> ok minus(X1, X2)
                 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 minus(mark X1, X2) -> mark minus(X1, X2)
                 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                 minus(X1, mark X2) -> mark minus(X1, X2)
                 1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
                 sel(ok X1, ok X2) -> ok sel(X1, X2)
                 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 sel(mark X1, X2) -> mark sel(X1, X2)
                 1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                 sel(X1, mark X2) -> mark sel(X1, X2)
                 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                 active zWquot(nil(), XS) -> mark nil()
                 2 + 0XS >= 2
                 active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
                 2 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 0Y + 0YS
                 active zWquot(X1, X2) -> zWquot(active X1, X2)
                 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active zWquot(X1, X2) -> zWquot(X1, active X2)
                 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active zWquot(XS, nil()) -> mark nil()
                 2 + 0XS >= 2
                 active quot(0(), s Y) -> mark 0()
                 1 + 0Y >= 2
                 active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
                 1 + 0X + 0Y >= 1 + 0X + 0Y
                 active quot(X1, X2) -> quot(active X1, X2)
                 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 active quot(X1, X2) -> quot(X1, active X2)
                 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 active minus(s X, s Y) -> mark minus(X, Y)
                 2 + 0X + 0Y >= 2 + 0X + 0Y
                 active minus(X1, X2) -> minus(active X1, X2)
                 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active minus(X1, X2) -> minus(X1, active X2)
                 2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
                 active minus(X, 0()) -> mark 0()
                 2 + 0X >= 2
                 active sel(0(), cons(X, XS)) -> mark X
                 3 + 1X + 1XS >= 1 + 1X
                 active sel(s N, cons(X, XS)) -> mark sel(N, XS)
                 3 + 1X + 1XS + 0N >= 2 + 1XS + 0N
                 active sel(X1, X2) -> sel(active X1, X2)
                 2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
                 active sel(X1, X2) -> sel(X1, active X2)
                 2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
                 active s X -> s active X
                 1 + 0X >= 0 + 0X
                 active from X -> from active X
                 2 + 1X >= 2 + 1X
                 active from X -> mark cons(X, from s X)
                 2 + 1X >= 3 + 1X
                 active cons(X1, X2) -> cons(active X1, X2)
                 2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
                 s ok X -> ok s X
                 0 + 0X >= 0 + 0X
                 s mark X -> mark s X
                 0 + 0X >= 1 + 0X
                 from ok X -> ok from X
                 1 + 0X >= 0 + 0X
                 from mark X -> mark from X
                 2 + 1X >= 2 + 1X
                 cons(ok X1, ok X2) -> ok cons(X1, X2)
                 1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
                 cons(mark X1, X2) -> mark cons(X1, X2)
                 2 + 1X1 + 1X2 >= 2 + 1X1 + 1X2
               Qed

SCC (3):
 Strict:
  { zWquot#(X1, mark X2) -> zWquot#(X1, X2),
    zWquot#(mark X1, X2) -> zWquot#(X1, X2),
   zWquot#(ok X1, ok X2) -> zWquot#(X1, X2)}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [minus](x0, x1) = 1,
   
   [quot](x0, x1) = x0 + 1,
   
   [zWquot](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [from](x0) = x0 + 1,
   
   [s](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 1,
   
   [zWquot#](x0, x1) = x0 + 1
  Strict:
   zWquot#(ok X1, ok X2) -> zWquot#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   zWquot#(mark X1, X2) -> zWquot#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   zWquot#(X1, mark X2) -> zWquot#(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 zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 2
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 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
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active zWquot(nil(), XS) -> mark nil()
   1 + 0XS >= 2
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   1 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(XS, nil()) -> mark nil()
   1 + 0XS >= 2
   active quot(0(), s Y) -> mark 0()
   3 + 1Y >= 2
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   3 + 0X + 1Y >= 4 + 0X + 1Y
   active quot(X1, X2) -> quot(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active quot(X1, X2) -> quot(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active minus(s X, s Y) -> mark minus(X, Y)
   2 + 0X + 0Y >= 2 + 0X + 0Y
   active minus(X1, X2) -> minus(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X1, X2) -> minus(X1, active X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   2 + 0X >= 2
   active sel(0(), cons(X, XS)) -> mark X
   3 + 1X + 0XS >= 1 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active s X -> s active X
   2 + 1X >= 2 + 1X
   active from X -> from active X
   2 + 1X >= 2 + 1X
   active from X -> mark cons(X, from s X)
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   s ok X -> ok s X
   2 + 1X >= 2 + 1X
   s mark X -> mark s X
   2 + 1X >= 2 + 1X
   from ok X -> ok from X
   2 + 1X >= 2 + 1X
   from mark X -> mark from X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {zWquot#(X1, mark X2) -> zWquot#(X1, X2)}
  
  SCC (1):
   Strict:
    {zWquot#(X1, mark X2) -> zWquot#(X1, X2)}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [zWquot#](x0, x1) = x0
    Strict:
     zWquot#(X1, mark X2) -> zWquot#(X1, X2)
     1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed


SCC (3):
 Strict:
  { minus#(X1, mark X2) -> minus#(X1, X2),
    minus#(mark X1, X2) -> minus#(X1, X2),
   minus#(ok X1, ok X2) -> minus#(X1, X2)}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [minus](x0, x1) = 1,
   
   [quot](x0, x1) = x0 + 1,
   
   [zWquot](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [from](x0) = x0 + 1,
   
   [s](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 1,
   
   [minus#](x0, x1) = x0 + 1
  Strict:
   minus#(ok X1, ok X2) -> minus#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   minus#(mark X1, X2) -> minus#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   minus#(X1, mark X2) -> minus#(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 zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 2
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 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
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active zWquot(nil(), XS) -> mark nil()
   1 + 0XS >= 2
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   1 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(XS, nil()) -> mark nil()
   1 + 0XS >= 2
   active quot(0(), s Y) -> mark 0()
   3 + 1Y >= 2
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   3 + 0X + 1Y >= 4 + 0X + 1Y
   active quot(X1, X2) -> quot(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active quot(X1, X2) -> quot(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active minus(s X, s Y) -> mark minus(X, Y)
   2 + 0X + 0Y >= 2 + 0X + 0Y
   active minus(X1, X2) -> minus(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X1, X2) -> minus(X1, active X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   2 + 0X >= 2
   active sel(0(), cons(X, XS)) -> mark X
   3 + 1X + 0XS >= 1 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active s X -> s active X
   2 + 1X >= 2 + 1X
   active from X -> from active X
   2 + 1X >= 2 + 1X
   active from X -> mark cons(X, from s X)
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   s ok X -> ok s X
   2 + 1X >= 2 + 1X
   s mark X -> mark s X
   2 + 1X >= 2 + 1X
   from ok X -> ok from X
   2 + 1X >= 2 + 1X
   from mark X -> mark from X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {minus#(X1, mark X2) -> minus#(X1, X2)}
  
  SCC (1):
   Strict:
    {minus#(X1, mark X2) -> minus#(X1, X2)}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [minus#](x0, x1) = x0
    Strict:
     minus#(X1, mark X2) -> minus#(X1, X2)
     1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed

SCC (3):
 Strict:
  { sel#(X1, mark X2) -> sel#(X1, X2),
    sel#(mark X1, X2) -> sel#(X1, X2),
   sel#(ok X1, ok X2) -> sel#(X1, X2)}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [minus](x0, x1) = 1,
   
   [quot](x0, x1) = x0 + 1,
   
   [zWquot](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [from](x0) = x0 + 1,
   
   [s](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 1,
   
   [sel#](x0, x1) = x0 + 1
  Strict:
   sel#(ok X1, ok X2) -> sel#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   sel#(mark X1, X2) -> sel#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   sel#(X1, mark X2) -> sel#(X1, X2)
   1 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 2
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 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
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active zWquot(nil(), XS) -> mark nil()
   1 + 0XS >= 2
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   1 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(XS, nil()) -> mark nil()
   1 + 0XS >= 2
   active quot(0(), s Y) -> mark 0()
   3 + 1Y >= 2
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   3 + 0X + 1Y >= 4 + 0X + 1Y
   active quot(X1, X2) -> quot(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active quot(X1, X2) -> quot(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active minus(s X, s Y) -> mark minus(X, Y)
   2 + 0X + 0Y >= 2 + 0X + 0Y
   active minus(X1, X2) -> minus(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X1, X2) -> minus(X1, active X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   2 + 0X >= 2
   active sel(0(), cons(X, XS)) -> mark X
   3 + 1X + 0XS >= 1 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active s X -> s active X
   2 + 1X >= 2 + 1X
   active from X -> from active X
   2 + 1X >= 2 + 1X
   active from X -> mark cons(X, from s X)
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   s ok X -> ok s X
   2 + 1X >= 2 + 1X
   s mark X -> mark s X
   2 + 1X >= 2 + 1X
   from ok X -> ok from X
   2 + 1X >= 2 + 1X
   from mark X -> mark from X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {sel#(X1, mark X2) -> sel#(X1, X2)}
  
  SCC (1):
   Strict:
    {sel#(X1, mark X2) -> sel#(X1, X2)}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [sel#](x0, x1) = x0
    Strict:
     sel#(X1, mark X2) -> sel#(X1, X2)
     1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed

SCC (2):
 Strict:
  { cons#(mark X1, X2) -> cons#(X1, X2),
   cons#(ok X1, ok X2) -> cons#(X1, X2)}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [minus](x0, x1) = 1,
   
   [quot](x0, x1) = x0 + 1,
   
   [zWquot](x0, x1) = x0 + 1,
   
   [mark](x0) = x0 + 1,
   
   [from](x0) = x0 + 1,
   
   [s](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 0,
   
   [cons#](x0, x1) = x0
  Strict:
   cons#(ok X1, ok X2) -> cons#(X1, X2)
   1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
   cons#(mark X1, X2) -> cons#(X1, X2)
   0 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
  Weak:
   top ok X -> top active X
   0 + 0X >= 0 + 0X
   top mark X -> top proper X
   0 + 0X >= 0 + 0X
   proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 1
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 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
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active zWquot(nil(), XS) -> mark nil()
   2 + 1XS >= 1
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active zWquot(XS, nil()) -> mark nil()
   2 + 0XS >= 1
   active quot(0(), s Y) -> mark 0()
   3 + 1Y >= 2
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   3 + 0X + 1Y >= 4 + 0X + 1Y
   active quot(X1, X2) -> quot(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active quot(X1, X2) -> quot(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active minus(s X, s Y) -> mark minus(X, Y)
   2 + 0X + 0Y >= 2 + 0X + 0Y
   active minus(X1, X2) -> minus(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X1, X2) -> minus(X1, active X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   2 + 0X >= 2
   active sel(0(), cons(X, XS)) -> mark X
   3 + 1X + 0XS >= 1 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active s X -> s active X
   2 + 1X >= 2 + 1X
   active from X -> from active X
   2 + 1X >= 2 + 1X
   active from X -> mark cons(X, from s X)
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   s ok X -> ok s X
   2 + 1X >= 2 + 1X
   s mark X -> mark s X
   2 + 1X >= 2 + 1X
   from ok X -> ok from X
   2 + 1X >= 2 + 1X
   from mark X -> mark from X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {cons#(mark X1, X2) -> cons#(X1, X2)}
  
  SCC (1):
   Strict:
    {cons#(mark X1, X2) -> cons#(X1, X2)}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [cons#](x0, x1) = x0
    Strict:
     cons#(mark X1, X2) -> cons#(X1, X2)
     1 + 1X1 + 0X2 >= 0 + 1X1 + 0X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed



SCC (2):
 Strict:
  {s# mark X -> s# X,
     s# ok X -> s# X}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = 0,
   
   [sel](x0, x1) = 0,
   
   [minus](x0, x1) = x0 + 1,
   
   [quot](x0, x1) = 0,
   
   [zWquot](x0, x1) = 0,
   
   [mark](x0) = x0,
   
   [from](x0) = 0,
   
   [s](x0) = 0,
   
   [active](x0) = 0,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 0,
   
   [s#](x0) = x0
  Strict:
   s# ok X -> s# X
   1 + 1X >= 0 + 1X
   s# mark X -> s# X
   0 + 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 zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 1
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 0 + 0X
   proper from X -> from proper X
   0 + 0X >= 0 + 0X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(nil(), XS) -> mark nil()
   0 + 0XS >= 0
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(XS, nil()) -> mark nil()
   0 + 0XS >= 0
   active quot(0(), s Y) -> mark 0()
   0 + 0Y >= 1
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   0 + 0X + 0Y >= 0 + 0X + 0Y
   active quot(X1, X2) -> quot(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active quot(X1, X2) -> quot(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active minus(s X, s Y) -> mark minus(X, Y)
   0 + 0X + 0Y >= 1 + 0X + 1Y
   active minus(X1, X2) -> minus(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active minus(X1, X2) -> minus(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   0 + 0X >= 1
   active sel(0(), cons(X, XS)) -> mark X
   0 + 0X + 0XS >= 0 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   0 + 0X + 0XS + 0N >= 0 + 0XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(X1, X2) -> sel(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active s X -> s active X
   0 + 0X >= 0 + 0X
   active from X -> from active X
   0 + 0X >= 0 + 0X
   active from X -> mark cons(X, from s X)
   0 + 0X >= 0 + 0X
   active cons(X1, X2) -> cons(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   s ok X -> ok s X
   0 + 0X >= 1 + 0X
   s mark X -> mark s X
   0 + 0X >= 0 + 0X
   from ok X -> ok from X
   0 + 0X >= 1 + 0X
   from mark X -> mark from X
   0 + 0X >= 0 + 0X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
 SCCS (1):
  Scc:
   {s# mark X -> s# X}
  
  SCC (1):
   Strict:
    {s# mark X -> s# X}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [s#](x0) = x0
    Strict:
     s# mark X -> s# X
     1 + 1X >= 0 + 1X
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed


SCC (2):
 Strict:
  {from# mark X -> from# X,
     from# ok X -> from# X}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = 0,
   
   [sel](x0, x1) = 0,
   
   [minus](x0, x1) = x0 + 1,
   
   [quot](x0, x1) = 0,
   
   [zWquot](x0, x1) = 0,
   
   [mark](x0) = x0,
   
   [from](x0) = 0,
   
   [s](x0) = 0,
   
   [active](x0) = 0,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 0,
   
   [from#](x0) = x0
  Strict:
   from# ok X -> from# X
   1 + 1X >= 0 + 1X
   from# mark X -> from# X
   0 + 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 zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 1
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 0 + 0X
   proper from X -> from proper X
   0 + 0X >= 0 + 0X
   proper cons(X1, X2) -> cons(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(nil(), XS) -> mark nil()
   0 + 0XS >= 0
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   0 + 0X + 0XS + 0Y + 0YS >= 0 + 0X + 0XS + 0Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(XS, nil()) -> mark nil()
   0 + 0XS >= 0
   active quot(0(), s Y) -> mark 0()
   0 + 0Y >= 1
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   0 + 0X + 0Y >= 0 + 0X + 0Y
   active quot(X1, X2) -> quot(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active quot(X1, X2) -> quot(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active minus(s X, s Y) -> mark minus(X, Y)
   0 + 0X + 0Y >= 1 + 0X + 1Y
   active minus(X1, X2) -> minus(active X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 1X2
   active minus(X1, X2) -> minus(X1, active X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   0 + 0X >= 1
   active sel(0(), cons(X, XS)) -> mark X
   0 + 0X + 0XS >= 0 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   0 + 0X + 0XS + 0N >= 0 + 0XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active sel(X1, X2) -> sel(X1, active X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active s X -> s active X
   0 + 0X >= 0 + 0X
   active from X -> from active X
   0 + 0X >= 0 + 0X
   active from X -> mark cons(X, from s X)
   0 + 0X >= 0 + 0X
   active cons(X1, X2) -> cons(active X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   s ok X -> ok s X
   0 + 0X >= 1 + 0X
   s mark X -> mark s X
   0 + 0X >= 0 + 0X
   from ok X -> ok from X
   0 + 0X >= 1 + 0X
   from mark X -> mark from X
   0 + 0X >= 0 + 0X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
 SCCS (1):
  Scc:
   {from# mark X -> from# X}
  
  SCC (1):
   Strict:
    {from# mark X -> from# X}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [from#](x0) = x0
    Strict:
     from# mark X -> from# X
     1 + 1X >= 0 + 1X
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed

SCC (3):
 Strict:
  { quot#(X1, mark X2) -> quot#(X1, X2),
    quot#(mark X1, X2) -> quot#(X1, X2),
   quot#(ok X1, ok X2) -> quot#(X1, X2)}
 Weak:
 {                      cons(mark X1, X2) -> mark cons(X1, X2),
                       cons(ok X1, ok X2) -> ok cons(X1, X2),
                              from mark X -> mark from X,
                                from ok X -> ok from X,
                                 s mark X -> mark s X,
                                   s ok X -> ok s X,
                      active cons(X1, X2) -> cons(active X1, X2),
                            active from X -> mark cons(X, from s X),
                            active from X -> from active X,
                               active s X -> s active X,
                       active sel(X1, X2) -> sel(X1, active X2),
                       active sel(X1, X2) -> sel(active X1, X2),
             active sel(s N, cons(X, XS)) -> mark sel(N, XS),
             active sel(0(), cons(X, XS)) -> mark X,
                     active minus(X, 0()) -> mark 0(),
                     active minus(X1, X2) -> minus(X1, active X2),
                     active minus(X1, X2) -> minus(active X1, X2),
                   active minus(s X, s Y) -> mark minus(X, Y),
                      active quot(X1, X2) -> quot(X1, active X2),
                      active quot(X1, X2) -> quot(active X1, X2),
                    active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                    active quot(0(), s Y) -> mark 0(),
                 active zWquot(XS, nil()) -> mark nil(),
                    active zWquot(X1, X2) -> zWquot(X1, active X2),
                    active zWquot(X1, X2) -> zWquot(active X1, X2),
  active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                 active zWquot(nil(), XS) -> mark nil(),
                         sel(X1, mark X2) -> mark sel(X1, X2),
                         sel(mark X1, X2) -> mark sel(X1, X2),
                        sel(ok X1, ok X2) -> ok sel(X1, X2),
                       minus(X1, mark X2) -> mark minus(X1, X2),
                       minus(mark X1, X2) -> mark minus(X1, X2),
                      minus(ok X1, ok X2) -> ok minus(X1, X2),
                        quot(X1, mark X2) -> mark quot(X1, X2),
                        quot(mark X1, X2) -> mark quot(X1, X2),
                       quot(ok X1, ok X2) -> ok quot(X1, X2),
                      zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                      zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                      proper cons(X1, X2) -> cons(proper X1, proper X2),
                            proper from X -> from proper X,
                               proper s X -> s proper X,
                       proper sel(X1, X2) -> sel(proper X1, proper X2),
                               proper 0() -> ok 0(),
                     proper minus(X1, X2) -> minus(proper X1, proper X2),
                      proper quot(X1, X2) -> quot(proper X1, proper X2),
                             proper nil() -> ok nil(),
                    proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                               top mark X -> top proper X,
                                 top ok X -> top active X}
 POLY:
  Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
  Interpretation:
   [cons](x0, x1) = x0 + 1,
   
   [sel](x0, x1) = x0 + 1,
   
   [minus](x0, x1) = 1,
   
   [quot](x0, x1) = x0 + 1,
   
   [zWquot](x0, x1) = 0,
   
   [mark](x0) = x0 + 1,
   
   [from](x0) = x0 + 1,
   
   [s](x0) = x0 + 1,
   
   [active](x0) = x0 + 1,
   
   [proper](x0) = 0,
   
   [ok](x0) = x0 + 1,
   
   [top](x0) = 0,
   
   [0] = 1,
   
   [nil] = 1,
   
   [quot#](x0, x1) = x0 + 1
  Strict:
   quot#(ok X1, ok X2) -> quot#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   quot#(mark X1, X2) -> quot#(X1, X2)
   2 + 1X1 + 0X2 >= 1 + 1X1 + 0X2
   quot#(X1, mark X2) -> quot#(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 zWquot(X1, X2) -> zWquot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   proper nil() -> ok nil()
   0 >= 2
   proper quot(X1, X2) -> quot(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper minus(X1, X2) -> minus(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper 0() -> ok 0()
   0 >= 2
   proper sel(X1, X2) -> sel(proper X1, proper X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   proper s X -> s proper X
   0 + 0X >= 1 + 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
   zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(mark X1, X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   zWquot(X1, mark X2) -> mark zWquot(X1, X2)
   0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   quot(ok X1, ok X2) -> ok quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(mark X1, X2) -> mark quot(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   quot(X1, mark X2) -> mark quot(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   minus(ok X1, ok X2) -> ok minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(mark X1, X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   minus(X1, mark X2) -> mark minus(X1, X2)
   1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
   sel(ok X1, ok X2) -> ok sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(mark X1, X2) -> mark sel(X1, X2)
   1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   sel(X1, mark X2) -> mark sel(X1, X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active zWquot(nil(), XS) -> mark nil()
   1 + 0XS >= 2
   active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
   1 + 0X + 0XS + 0Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
   active zWquot(X1, X2) -> zWquot(active X1, X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(X1, X2) -> zWquot(X1, active X2)
   1 + 0X1 + 0X2 >= 0 + 0X1 + 0X2
   active zWquot(XS, nil()) -> mark nil()
   1 + 0XS >= 2
   active quot(0(), s Y) -> mark 0()
   3 + 1Y >= 2
   active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
   3 + 0X + 1Y >= 4 + 0X + 1Y
   active quot(X1, X2) -> quot(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active quot(X1, X2) -> quot(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active minus(s X, s Y) -> mark minus(X, Y)
   2 + 0X + 0Y >= 2 + 0X + 0Y
   active minus(X1, X2) -> minus(active X1, X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X1, X2) -> minus(X1, active X2)
   2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
   active minus(X, 0()) -> mark 0()
   2 + 0X >= 2
   active sel(0(), cons(X, XS)) -> mark X
   3 + 1X + 0XS >= 1 + 1X
   active sel(s N, cons(X, XS)) -> mark sel(N, XS)
   3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
   active sel(X1, X2) -> sel(active X1, X2)
   2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
   active sel(X1, X2) -> sel(X1, active X2)
   2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
   active s X -> s active X
   2 + 1X >= 2 + 1X
   active from X -> from active X
   2 + 1X >= 2 + 1X
   active from X -> mark cons(X, from s X)
   2 + 1X >= 2 + 1X
   active cons(X1, X2) -> cons(active X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   s ok X -> ok s X
   2 + 1X >= 2 + 1X
   s mark X -> mark s X
   2 + 1X >= 2 + 1X
   from ok X -> ok from X
   2 + 1X >= 2 + 1X
   from mark X -> mark from X
   2 + 1X >= 2 + 1X
   cons(ok X1, ok X2) -> ok cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   cons(mark X1, X2) -> mark cons(X1, X2)
   2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
 SCCS (1):
  Scc:
   {quot#(X1, mark X2) -> quot#(X1, X2)}
  
  SCC (1):
   Strict:
    {quot#(X1, mark X2) -> quot#(X1, X2)}
   Weak:
   {                      cons(mark X1, X2) -> mark cons(X1, X2),
                         cons(ok X1, ok X2) -> ok cons(X1, X2),
                                from mark X -> mark from X,
                                  from ok X -> ok from X,
                                   s mark X -> mark s X,
                                     s ok X -> ok s X,
                        active cons(X1, X2) -> cons(active X1, X2),
                              active from X -> mark cons(X, from s X),
                              active from X -> from active X,
                                 active s X -> s active X,
                         active sel(X1, X2) -> sel(X1, active X2),
                         active sel(X1, X2) -> sel(active X1, X2),
               active sel(s N, cons(X, XS)) -> mark sel(N, XS),
               active sel(0(), cons(X, XS)) -> mark X,
                       active minus(X, 0()) -> mark 0(),
                       active minus(X1, X2) -> minus(X1, active X2),
                       active minus(X1, X2) -> minus(active X1, X2),
                     active minus(s X, s Y) -> mark minus(X, Y),
                        active quot(X1, X2) -> quot(X1, active X2),
                        active quot(X1, X2) -> quot(active X1, X2),
                      active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y),
                      active quot(0(), s Y) -> mark 0(),
                   active zWquot(XS, nil()) -> mark nil(),
                      active zWquot(X1, X2) -> zWquot(X1, active X2),
                      active zWquot(X1, X2) -> zWquot(active X1, X2),
    active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS)),
                   active zWquot(nil(), XS) -> mark nil(),
                           sel(X1, mark X2) -> mark sel(X1, X2),
                           sel(mark X1, X2) -> mark sel(X1, X2),
                          sel(ok X1, ok X2) -> ok sel(X1, X2),
                         minus(X1, mark X2) -> mark minus(X1, X2),
                         minus(mark X1, X2) -> mark minus(X1, X2),
                        minus(ok X1, ok X2) -> ok minus(X1, X2),
                          quot(X1, mark X2) -> mark quot(X1, X2),
                          quot(mark X1, X2) -> mark quot(X1, X2),
                         quot(ok X1, ok X2) -> ok quot(X1, X2),
                        zWquot(X1, mark X2) -> mark zWquot(X1, X2),
                        zWquot(mark X1, X2) -> mark zWquot(X1, X2),
                       zWquot(ok X1, ok X2) -> ok zWquot(X1, X2),
                        proper cons(X1, X2) -> cons(proper X1, proper X2),
                              proper from X -> from proper X,
                                 proper s X -> s proper X,
                         proper sel(X1, X2) -> sel(proper X1, proper X2),
                                 proper 0() -> ok 0(),
                       proper minus(X1, X2) -> minus(proper X1, proper X2),
                        proper quot(X1, X2) -> quot(proper X1, proper X2),
                               proper nil() -> ok nil(),
                      proper zWquot(X1, X2) -> zWquot(proper X1, proper X2),
                                 top mark X -> top proper X,
                                   top ok X -> top active X}
   POLY:
    Mode: weak, max_in=1, output_bits=-1, dnum=1, ur=true
    Interpretation:
     [cons](x0, x1) = x0 + 1,
     
     [sel](x0, x1) = x0 + 1,
     
     [minus](x0, x1) = 1,
     
     [quot](x0, x1) = x0 + 1,
     
     [zWquot](x0, x1) = x0 + 1,
     
     [mark](x0) = x0 + 1,
     
     [from](x0) = x0 + 1,
     
     [s](x0) = x0 + 1,
     
     [active](x0) = x0 + 1,
     
     [proper](x0) = 0,
     
     [ok](x0) = x0 + 1,
     
     [top](x0) = x0 + 1,
     
     [0] = 1,
     
     [nil] = 0,
     
     [quot#](x0, x1) = x0
    Strict:
     quot#(X1, mark X2) -> quot#(X1, X2)
     1 + 0X1 + 1X2 >= 0 + 0X1 + 1X2
    Weak:
     top ok X -> top active X
     2 + 1X >= 2 + 1X
     top mark X -> top proper X
     2 + 1X >= 1 + 0X
     proper zWquot(X1, X2) -> zWquot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper nil() -> ok nil()
     0 >= 1
     proper quot(X1, X2) -> quot(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper minus(X1, X2) -> minus(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper 0() -> ok 0()
     0 >= 2
     proper sel(X1, X2) -> sel(proper X1, proper X2)
     0 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     proper s X -> s proper X
     0 + 0X >= 1 + 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
     zWquot(ok X1, ok X2) -> ok zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(mark X1, X2) -> mark zWquot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     zWquot(X1, mark X2) -> mark zWquot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(ok X1, ok X2) -> ok quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(mark X1, X2) -> mark quot(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     quot(X1, mark X2) -> mark quot(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     minus(ok X1, ok X2) -> ok minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(mark X1, X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     minus(X1, mark X2) -> mark minus(X1, X2)
     1 + 0X1 + 0X2 >= 2 + 0X1 + 0X2
     sel(ok X1, ok X2) -> ok sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(mark X1, X2) -> mark sel(X1, X2)
     1 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     sel(X1, mark X2) -> mark sel(X1, X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(nil(), XS) -> mark nil()
     2 + 1XS >= 1
     active zWquot(cons(X, XS), cons(Y, YS)) -> mark cons(quot(X, Y), zWquot(XS, YS))
     3 + 0X + 0XS + 1Y + 0YS >= 3 + 0X + 0XS + 1Y + 0YS
     active zWquot(X1, X2) -> zWquot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active zWquot(X1, X2) -> zWquot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active zWquot(XS, nil()) -> mark nil()
     2 + 0XS >= 1
     active quot(0(), s Y) -> mark 0()
     3 + 1Y >= 2
     active quot(s X, s Y) -> mark s quot(minus(X, Y), s Y)
     3 + 0X + 1Y >= 4 + 0X + 1Y
     active quot(X1, X2) -> quot(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active quot(X1, X2) -> quot(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active minus(s X, s Y) -> mark minus(X, Y)
     2 + 0X + 0Y >= 2 + 0X + 0Y
     active minus(X1, X2) -> minus(active X1, X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X1, X2) -> minus(X1, active X2)
     2 + 0X1 + 0X2 >= 1 + 0X1 + 0X2
     active minus(X, 0()) -> mark 0()
     2 + 0X >= 2
     active sel(0(), cons(X, XS)) -> mark X
     3 + 1X + 0XS >= 1 + 1X
     active sel(s N, cons(X, XS)) -> mark sel(N, XS)
     3 + 1X + 0XS + 0N >= 2 + 1XS + 0N
     active sel(X1, X2) -> sel(active X1, X2)
     2 + 0X1 + 1X2 >= 1 + 0X1 + 1X2
     active sel(X1, X2) -> sel(X1, active X2)
     2 + 0X1 + 1X2 >= 2 + 0X1 + 1X2
     active s X -> s active X
     2 + 1X >= 2 + 1X
     active from X -> from active X
     2 + 1X >= 2 + 1X
     active from X -> mark cons(X, from s X)
     2 + 1X >= 2 + 1X
     active cons(X1, X2) -> cons(active X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     s ok X -> ok s X
     2 + 1X >= 2 + 1X
     s mark X -> mark s X
     2 + 1X >= 2 + 1X
     from ok X -> ok from X
     2 + 1X >= 2 + 1X
     from mark X -> mark from X
     2 + 1X >= 2 + 1X
     cons(ok X1, ok X2) -> ok cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
     cons(mark X1, X2) -> mark cons(X1, X2)
     2 + 1X1 + 0X2 >= 2 + 1X1 + 0X2
   Qed