/export/starexec/sandbox/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Problem:
 minus(x,0()) -> x
 minus(s(x),s(y)) -> minus(x,y)
 quot(0(),s(y)) -> 0()
 quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
 plus(0(),y) -> y
 plus(s(x),y) -> s(plus(x,y))
 minus(minus(x,y),z) -> minus(x,plus(y,z))
 app(nil(),k) -> k
 app(l,nil()) -> l
 app(cons(x,l),k) -> cons(x,app(l,k))
 sum(cons(x,nil())) -> cons(x,nil())
 sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
 sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
 plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
 plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
 plus(zero(),y) -> y
 plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
 id(x) -> x
 if(true(),x,y) -> x
 if(false(),x,y) -> y
 not(x) -> if(x,false(),true())
 gt(s(x),zero()) -> true()
 gt(zero(),y) -> false()
 gt(s(x),s(y)) -> gt(x,y)

Proof:
 DP Processor:
  DPs:
   minus#(s(x),s(y)) -> minus#(x,y)
   quot#(s(x),s(y)) -> minus#(x,y)
   quot#(s(x),s(y)) -> quot#(minus(x,y),s(y))
   plus#(s(x),y) -> plus#(x,y)
   minus#(minus(x,y),z) -> plus#(y,z)
   minus#(minus(x,y),z) -> minus#(x,plus(y,z))
   app#(cons(x,l),k) -> app#(l,k)
   sum#(cons(x,cons(y,l))) -> plus#(x,y)
   sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
   sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
   sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
   sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
   plus#(s(x),s(y)) -> id#(y)
   plus#(s(x),s(y)) -> id#(x)
   plus#(s(x),s(y)) -> not#(gt(x,y))
   plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
   plus#(s(x),s(y)) -> gt#(x,y)
   plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
   plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
   plus#(s(x),x) -> id#(x)
   plus#(s(x),x) -> gt#(x,x)
   plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
   plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
   plus#(id(x),s(y)) -> gt#(s(y),y)
   plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
   plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
   not#(x) -> if#(x,false(),true())
   gt#(s(x),s(y)) -> gt#(x,y)
  TRS:
   minus(x,0()) -> x
   minus(s(x),s(y)) -> minus(x,y)
   quot(0(),s(y)) -> 0()
   quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
   plus(0(),y) -> y
   plus(s(x),y) -> s(plus(x,y))
   minus(minus(x,y),z) -> minus(x,plus(y,z))
   app(nil(),k) -> k
   app(l,nil()) -> l
   app(cons(x,l),k) -> cons(x,app(l,k))
   sum(cons(x,nil())) -> cons(x,nil())
   sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
   sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
   plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
   plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
   plus(zero(),y) -> y
   plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
   id(x) -> x
   if(true(),x,y) -> x
   if(false(),x,y) -> y
   not(x) -> if(x,false(),true())
   gt(s(x),zero()) -> true()
   gt(zero(),y) -> false()
   gt(s(x),s(y)) -> gt(x,y)
  TDG Processor:
   DPs:
    minus#(s(x),s(y)) -> minus#(x,y)
    quot#(s(x),s(y)) -> minus#(x,y)
    quot#(s(x),s(y)) -> quot#(minus(x,y),s(y))
    plus#(s(x),y) -> plus#(x,y)
    minus#(minus(x,y),z) -> plus#(y,z)
    minus#(minus(x,y),z) -> minus#(x,plus(y,z))
    app#(cons(x,l),k) -> app#(l,k)
    sum#(cons(x,cons(y,l))) -> plus#(x,y)
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
    sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
    plus#(s(x),s(y)) -> id#(y)
    plus#(s(x),s(y)) -> id#(x)
    plus#(s(x),s(y)) -> not#(gt(x,y))
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    plus#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    plus#(s(x),x) -> id#(x)
    plus#(s(x),x) -> gt#(x,x)
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    plus#(id(x),s(y)) -> gt#(s(y),y)
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    not#(x) -> if#(x,false(),true())
    gt#(s(x),s(y)) -> gt#(x,y)
   TRS:
    minus(x,0()) -> x
    minus(s(x),s(y)) -> minus(x,y)
    quot(0(),s(y)) -> 0()
    quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
    plus(0(),y) -> y
    plus(s(x),y) -> s(plus(x,y))
    minus(minus(x,y),z) -> minus(x,plus(y,z))
    app(nil(),k) -> k
    app(l,nil()) -> l
    app(cons(x,l),k) -> cons(x,app(l,k))
    sum(cons(x,nil())) -> cons(x,nil())
    sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
    sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
    plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
    plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
    plus(zero(),y) -> y
    plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
    id(x) -> x
    if(true(),x,y) -> x
    if(false(),x,y) -> y
    not(x) -> if(x,false(),true())
    gt(s(x),zero()) -> true()
    gt(zero(),y) -> false()
    gt(s(x),s(y)) -> gt(x,y)
   graph:
    gt#(s(x),s(y)) -> gt#(x,y) ->
    gt#(s(x),s(y)) -> gt#(x,y)
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
    sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
    sum#(cons(x,cons(y,l))) -> plus#(x,y)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(id(x),s(y)) -> gt#(s(y),y)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),x) -> gt#(x,x)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),x) -> id#(x)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> gt#(x,y)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> not#(gt(x,y))
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> id#(x)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> id#(y)
    sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
    plus#(s(x),y) -> plus#(x,y)
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
    sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
    sum#(cons(x,cons(y,l))) -> plus#(x,y)
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
    sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
    sum#(cons(x,cons(y,l))) -> plus#(x,y)
    sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k)))) ->
    app#(cons(x,l),k) -> app#(l,k)
    app#(cons(x,l),k) -> app#(l,k) ->
    app#(cons(x,l),k) -> app#(l,k)
    plus#(id(x),s(y)) -> gt#(s(y),y) ->
    gt#(s(x),s(y)) -> gt#(x,y)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(id(x),s(y)) -> gt#(s(y),y)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),x) -> gt#(x,x)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),x) -> id#(x)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> gt#(x,y)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> not#(gt(x,y))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> id#(x)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),s(y)) -> id#(y)
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
    plus#(s(x),y) -> plus#(x,y)
    plus#(s(x),s(y)) -> gt#(x,y) -> gt#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),s(y)) -> not#(gt(x,y)) ->
    not#(x) -> if#(x,false(),true())
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(id(x),s(y)) -> gt#(s(y),y)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),x) -> gt#(x,x)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),x) -> id#(x)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> not#(gt(x,y))
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> id#(x)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),s(y)) -> id#(y)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
    plus#(s(x),y) -> plus#(x,y)
    plus#(s(x),y) -> plus#(x,y) ->
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    plus#(s(x),y) -> plus#(x,y) ->
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    plus#(s(x),y) -> plus#(x,y) -> plus#(id(x),s(y)) -> gt#(s(y),y)
    plus#(s(x),y) -> plus#(x,y) ->
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    plus#(s(x),y) -> plus#(x,y) ->
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),x) -> gt#(x,x)
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),x) -> id#(x)
    plus#(s(x),y) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),y) -> plus#(x,y) ->
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),s(y)) -> not#(gt(x,y))
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),s(y)) -> id#(x)
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),s(y)) -> id#(y)
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),y) -> plus#(x,y)
    plus#(s(x),x) -> gt#(x,x) ->
    gt#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(id(x),s(y)) -> gt#(s(y),y)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),x) -> gt#(x,x)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),x) -> id#(x)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> not#(gt(x,y))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> id#(x)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),s(y)) -> id#(y)
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
    plus#(s(x),y) -> plus#(x,y)
    quot#(s(x),s(y)) -> quot#(minus(x,y),s(y)) ->
    quot#(s(x),s(y)) -> quot#(minus(x,y),s(y))
    quot#(s(x),s(y)) -> quot#(minus(x,y),s(y)) ->
    quot#(s(x),s(y)) -> minus#(x,y)
    quot#(s(x),s(y)) -> minus#(x,y) ->
    minus#(minus(x,y),z) -> minus#(x,plus(y,z))
    quot#(s(x),s(y)) -> minus#(x,y) ->
    minus#(minus(x,y),z) -> plus#(y,z)
    quot#(s(x),s(y)) -> minus#(x,y) ->
    minus#(s(x),s(y)) -> minus#(x,y)
    minus#(s(x),s(y)) -> minus#(x,y) ->
    minus#(minus(x,y),z) -> minus#(x,plus(y,z))
    minus#(s(x),s(y)) -> minus#(x,y) ->
    minus#(minus(x,y),z) -> plus#(y,z)
    minus#(s(x),s(y)) -> minus#(x,y) ->
    minus#(s(x),s(y)) -> minus#(x,y)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(id(x),s(y)) -> gt#(s(y),y)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),x) -> gt#(x,x)
    minus#(minus(x,y),z) -> plus#(y,z) -> plus#(s(x),x) -> id#(x)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> gt#(x,y)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> not#(gt(x,y))
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> id#(x)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),s(y)) -> id#(y)
    minus#(minus(x,y),z) -> plus#(y,z) ->
    plus#(s(x),y) -> plus#(x,y)
    minus#(minus(x,y),z) -> minus#(x,plus(y,z)) ->
    minus#(minus(x,y),z) -> minus#(x,plus(y,z))
    minus#(minus(x,y),z) -> minus#(x,plus(y,z)) ->
    minus#(minus(x,y),z) -> plus#(y,z)
    minus#(minus(x,y),z) -> minus#(x,plus(y,z)) -> minus#(s(x),s(y)) -> minus#(x,y)
   SCC Processor:
    #sccs: 6
    #rules: 12
    #arcs: 123/784
    DPs:
     quot#(s(x),s(y)) -> quot#(minus(x,y),s(y))
    TRS:
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     minus(minus(x,y),z) -> minus(x,plus(y,z))
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
    Subterm Criterion Processor:
     simple projection:
      pi(minus) = 0
      pi(quot#) = 0
     problem:
      DPs:
       
      TRS:
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       minus(minus(x,y),z) -> minus(x,plus(y,z))
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
     Qed
    
    DPs:
     minus#(s(x),s(y)) -> minus#(x,y)
     minus#(minus(x,y),z) -> minus#(x,plus(y,z))
    TRS:
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     minus(minus(x,y),z) -> minus(x,plus(y,z))
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
    Subterm Criterion Processor:
     simple projection:
      pi(minus#) = 0
     problem:
      DPs:
       
      TRS:
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       minus(minus(x,y),z) -> minus(x,plus(y,z))
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
     Qed
    
    DPs:
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
    TRS:
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     minus(minus(x,y),z) -> minus(x,plus(y,z))
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
    EDG Processor:
     DPs:
      sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
     TRS:
      minus(x,0()) -> x
      minus(s(x),s(y)) -> minus(x,y)
      quot(0(),s(y)) -> 0()
      quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
      plus(0(),y) -> y
      plus(s(x),y) -> s(plus(x,y))
      minus(minus(x,y),z) -> minus(x,plus(y,z))
      app(nil(),k) -> k
      app(l,nil()) -> l
      app(cons(x,l),k) -> cons(x,app(l,k))
      sum(cons(x,nil())) -> cons(x,nil())
      sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
      sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
      plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
      plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
      plus(zero(),y) -> y
      plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
      id(x) -> x
      if(true(),x,y) -> x
      if(false(),x,y) -> y
      not(x) -> if(x,false(),true())
      gt(s(x),zero()) -> true()
      gt(zero(),y) -> false()
      gt(s(x),s(y)) -> gt(x,y)
     graph:
      sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
      sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
      sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
      sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
     SCC Processor:
      #sccs: 2
      #rules: 2
      #arcs: 5/9
      DPs:
       sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
      TRS:
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       minus(minus(x,y),z) -> minus(x,plus(y,z))
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Usable Rule Processor:
       DPs:
        sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
       TRS:
        sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
        sum(cons(x,nil())) -> cons(x,nil())
        plus(0(),y) -> y
        plus(s(x),y) -> s(plus(x,y))
        plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
        plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
        plus(zero(),y) -> y
        plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
        id(x) -> x
        not(x) -> if(x,false(),true())
        gt(s(x),zero()) -> true()
        gt(zero(),y) -> false()
        gt(s(x),s(y)) -> gt(x,y)
        if(true(),x,y) -> x
        if(false(),x,y) -> y
        app(nil(),k) -> k
        app(l,nil()) -> l
        app(cons(x,l),k) -> cons(x,app(l,k))
       Matrix Interpretation Processor: dim=1
        
        usable rules:
         sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
         sum(cons(x,nil())) -> cons(x,nil())
         app(nil(),k) -> k
         app(l,nil()) -> l
         app(cons(x,l),k) -> cons(x,app(l,k))
        interpretation:
         [sum#](x0) = 4x0 + 4,
         
         [false] = 3,
         
         [true] = 0,
         
         [zero] = 0,
         
         [id](x0) = 4x0 + 1,
         
         [not](x0) = x0 + 1,
         
         [if](x0, x1, x2) = 3x0 + 4x1 + x2 + 7,
         
         [gt](x0, x1) = 2x1 + 3,
         
         [sum](x0) = 3,
         
         [cons](x0, x1) = x1 + 2,
         
         [app](x0, x1) = x0 + x1 + 2,
         
         [nil] = 1,
         
         [plus](x0, x1) = 4,
         
         [s](x0) = 0,
         
         [0] = 0
        orientation:
         sum#(app(l,cons(x,cons(y,k)))) = 4k + 4l + 28 >= 4l + 24 = sum#(app(l,sum(cons(x,cons(y,k)))))
         
         sum(cons(x,cons(y,l))) = 3 >= 3 = sum(cons(plus(x,y),l))
         
         sum(cons(x,nil())) = 3 >= 3 = cons(x,nil())
         
         plus(0(),y) = 4 >= y = y
         
         plus(s(x),y) = 4 >= 0 = s(plus(x,y))
         
         plus(s(x),s(y)) = 4 >= 0 = s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
         
         plus(s(x),x) = 4 >= 4 = plus(if(gt(x,x),id(x),id(x)),s(x))
         
         plus(zero(),y) = 4 >= y = y
         
         plus(id(x),s(y)) = 4 >= 0 = s(plus(x,if(gt(s(y),y),y,s(y))))
         
         id(x) = 4x + 1 >= x = x
         
         not(x) = x + 1 >= 3x + 19 = if(x,false(),true())
         
         gt(s(x),zero()) = 3 >= 0 = true()
         
         gt(zero(),y) = 2y + 3 >= 3 = false()
         
         gt(s(x),s(y)) = 3 >= 2y + 3 = gt(x,y)
         
         if(true(),x,y) = 4x + y + 7 >= x = x
         
         if(false(),x,y) = 4x + y + 16 >= y = y
         
         app(nil(),k) = k + 3 >= k = k
         
         app(l,nil()) = l + 3 >= l = l
         
         app(cons(x,l),k) = k + l + 4 >= k + l + 4 = cons(x,app(l,k))
        problem:
         DPs:
          
         TRS:
          sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
          sum(cons(x,nil())) -> cons(x,nil())
          plus(0(),y) -> y
          plus(s(x),y) -> s(plus(x,y))
          plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
          plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
          plus(zero(),y) -> y
          plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
          id(x) -> x
          not(x) -> if(x,false(),true())
          gt(s(x),zero()) -> true()
          gt(zero(),y) -> false()
          gt(s(x),s(y)) -> gt(x,y)
          if(true(),x,y) -> x
          if(false(),x,y) -> y
          app(nil(),k) -> k
          app(l,nil()) -> l
          app(cons(x,l),k) -> cons(x,app(l,k))
        Qed
      
      DPs:
       sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      TRS:
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       minus(minus(x,y),z) -> minus(x,plus(y,z))
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Subterm Criterion Processor:
       simple projection:
        pi(cons) = [1,1,1]
        pi(sum#) = 0
       problem:
        DPs:
         
        TRS:
         minus(x,0()) -> x
         minus(s(x),s(y)) -> minus(x,y)
         quot(0(),s(y)) -> 0()
         quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
         plus(0(),y) -> y
         plus(s(x),y) -> s(plus(x,y))
         minus(minus(x,y),z) -> minus(x,plus(y,z))
         app(nil(),k) -> k
         app(l,nil()) -> l
         app(cons(x,l),k) -> cons(x,app(l,k))
         sum(cons(x,nil())) -> cons(x,nil())
         sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
         sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
         plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
         plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
         plus(zero(),y) -> y
         plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
         id(x) -> x
         if(true(),x,y) -> x
         if(false(),x,y) -> y
         not(x) -> if(x,false(),true())
         gt(s(x),zero()) -> true()
         gt(zero(),y) -> false()
         gt(s(x),s(y)) -> gt(x,y)
       Qed
    
    DPs:
     app#(cons(x,l),k) -> app#(l,k)
    TRS:
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     minus(minus(x,y),z) -> minus(x,plus(y,z))
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
    Subterm Criterion Processor:
     simple projection:
      pi(app#) = 0
     problem:
      DPs:
       
      TRS:
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       minus(minus(x,y),z) -> minus(x,plus(y,z))
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
     Qed
    
    DPs:
     plus#(s(x),y) -> plus#(x,y)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    TRS:
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     minus(minus(x,y),z) -> minus(x,plus(y,z))
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
    Usable Rule Processor:
     DPs:
      plus#(s(x),y) -> plus#(x,y)
      plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
      plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
      plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
     TRS:
      id(x) -> x
      not(x) -> if(x,false(),true())
      gt(s(x),zero()) -> true()
      gt(zero(),y) -> false()
      gt(s(x),s(y)) -> gt(x,y)
      if(true(),x,y) -> x
      if(false(),x,y) -> y
     Arctic Interpretation Processor:
      dimension: 1
      usable rules:
       id(x) -> x
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
       if(true(),x,y) -> x
       if(false(),x,y) -> y
      interpretation:
       [plus#](x0, x1) = x0 + x1,
       
       [false] = 5,
       
       [true] = 5,
       
       [zero] = 0,
       
       [id](x0) = x0,
       
       [not](x0) = x0 + 5,
       
       [if](x0, x1, x2) = -13x0 + x1 + x2,
       
       [gt](x0, x1) = 5x0 + 5x1,
       
       [s](x0) = 1x0 + 0
      orientation:
       plus#(s(x),y) = 1x + y + 0 >= x + y = plus#(x,y)
       
       plus#(s(x),s(y)) = 1x + 1y + 0 >= x + y + -8 = plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
       
       plus#(s(x),x) = 1x + 0 >= 1x + 0 = plus#(if(gt(x,x),id(x),id(x)),s(x))
       
       plus#(id(x),s(y)) = x + 1y + 0 >= x + 1y + 0 = plus#(x,if(gt(s(y),y),y,s(y)))
       
       id(x) = x >= x = x
       
       not(x) = x + 5 >= -13x + 5 = if(x,false(),true())
       
       gt(s(x),zero()) = 6x + 5 >= 5 = true()
       
       gt(zero(),y) = 5y + 5 >= 5 = false()
       
       gt(s(x),s(y)) = 6x + 6y + 5 >= 5x + 5y = gt(x,y)
       
       if(true(),x,y) = x + y + -8 >= x = x
       
       if(false(),x,y) = x + y + -8 >= y = y
      problem:
       DPs:
        plus#(s(x),y) -> plus#(x,y)
        plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
        plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
       TRS:
        id(x) -> x
        not(x) -> if(x,false(),true())
        gt(s(x),zero()) -> true()
        gt(zero(),y) -> false()
        gt(s(x),s(y)) -> gt(x,y)
        if(true(),x,y) -> x
        if(false(),x,y) -> y
      Restore Modifier:
       DPs:
        plus#(s(x),y) -> plus#(x,y)
        plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
        plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
       TRS:
        minus(x,0()) -> x
        minus(s(x),s(y)) -> minus(x,y)
        quot(0(),s(y)) -> 0()
        quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
        plus(0(),y) -> y
        plus(s(x),y) -> s(plus(x,y))
        minus(minus(x,y),z) -> minus(x,plus(y,z))
        app(nil(),k) -> k
        app(l,nil()) -> l
        app(cons(x,l),k) -> cons(x,app(l,k))
        sum(cons(x,nil())) -> cons(x,nil())
        sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
        sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
        plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
        plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
        plus(zero(),y) -> y
        plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
        id(x) -> x
        if(true(),x,y) -> x
        if(false(),x,y) -> y
        not(x) -> if(x,false(),true())
        gt(s(x),zero()) -> true()
        gt(zero(),y) -> false()
        gt(s(x),s(y)) -> gt(x,y)
       Usable Rule Processor:
        DPs:
         plus#(s(x),y) -> plus#(x,y)
         plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
         plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
        TRS:
         id(x) -> x
         gt(s(x),zero()) -> true()
         gt(zero(),y) -> false()
         gt(s(x),s(y)) -> gt(x,y)
         if(true(),x,y) -> x
         if(false(),x,y) -> y
        Arctic Interpretation Processor:
         dimension: 1
         usable rules:
          id(x) -> x
          if(true(),x,y) -> x
          if(false(),x,y) -> y
         interpretation:
          [plus#](x0, x1) = x0,
          
          [false] = 0,
          
          [true] = 0,
          
          [zero] = 3,
          
          [id](x0) = 2x0,
          
          [if](x0, x1, x2) = x1 + x2 + -8,
          
          [gt](x0, x1) = x1 + -14,
          
          [s](x0) = 2x0 + 0
         orientation:
          plus#(s(x),y) = 2x + 0 >= x = plus#(x,y)
          
          plus#(s(x),x) = 2x + 0 >= 2x + -8 = plus#(if(gt(x,x),id(x),id(x)),s(x))
          
          plus#(id(x),s(y)) = 2x >= x = plus#(x,if(gt(s(y),y),y,s(y)))
          
          id(x) = 2x >= x = x
          
          gt(s(x),zero()) = 3 >= 0 = true()
          
          gt(zero(),y) = y + -14 >= 0 = false()
          
          gt(s(x),s(y)) = 2y + 0 >= y + -14 = gt(x,y)
          
          if(true(),x,y) = x + y + -8 >= x = x
          
          if(false(),x,y) = x + y + -8 >= y = y
         problem:
          DPs:
           plus#(s(x),y) -> plus#(x,y)
           plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
          TRS:
           id(x) -> x
           gt(s(x),zero()) -> true()
           gt(zero(),y) -> false()
           gt(s(x),s(y)) -> gt(x,y)
           if(true(),x,y) -> x
           if(false(),x,y) -> y
         Restore Modifier:
          DPs:
           plus#(s(x),y) -> plus#(x,y)
           plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
          TRS:
           minus(x,0()) -> x
           minus(s(x),s(y)) -> minus(x,y)
           quot(0(),s(y)) -> 0()
           quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
           plus(0(),y) -> y
           plus(s(x),y) -> s(plus(x,y))
           minus(minus(x,y),z) -> minus(x,plus(y,z))
           app(nil(),k) -> k
           app(l,nil()) -> l
           app(cons(x,l),k) -> cons(x,app(l,k))
           sum(cons(x,nil())) -> cons(x,nil())
           sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
           sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
           plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
           plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
           plus(zero(),y) -> y
           plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
           id(x) -> x
           if(true(),x,y) -> x
           if(false(),x,y) -> y
           not(x) -> if(x,false(),true())
           gt(s(x),zero()) -> true()
           gt(zero(),y) -> false()
           gt(s(x),s(y)) -> gt(x,y)
          Usable Rule Processor:
           DPs:
            plus#(s(x),y) -> plus#(x,y)
            plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
           TRS:
            id(x) -> x
            gt(s(x),zero()) -> true()
            gt(zero(),y) -> false()
            gt(s(x),s(y)) -> gt(x,y)
            if(true(),x,y) -> x
            if(false(),x,y) -> y
           Arctic Interpretation Processor:
            dimension: 1
            usable rules:
             id(x) -> x
             if(true(),x,y) -> x
             if(false(),x,y) -> y
            interpretation:
             [plus#](x0, x1) = -8x0 + 0,
             
             [false] = 0,
             
             [true] = 3,
             
             [zero] = 10,
             
             [id](x0) = x0,
             
             [if](x0, x1, x2) = x1 + x2 + 8,
             
             [gt](x0, x1) = -9x0 + -3x1 + 0,
             
             [s](x0) = 10x0 + 9
            orientation:
             plus#(s(x),y) = 2x + 1 >= -8x + 0 = plus#(x,y)
             
             plus#(s(x),x) = 2x + 1 >= -8x + 0 = plus#(if(gt(x,x),id(x),id(x)),s(x))
             
             id(x) = x >= x = x
             
             gt(s(x),zero()) = 1x + 7 >= 3 = true()
             
             gt(zero(),y) = -3y + 1 >= 0 = false()
             
             gt(s(x),s(y)) = 1x + 7y + 6 >= -9x + -3y + 0 = gt(x,y)
             
             if(true(),x,y) = x + y + 8 >= x = x
             
             if(false(),x,y) = x + y + 8 >= y = y
            problem:
             DPs:
              plus#(s(x),y) -> plus#(x,y)
             TRS:
              id(x) -> x
              gt(s(x),zero()) -> true()
              gt(zero(),y) -> false()
              gt(s(x),s(y)) -> gt(x,y)
              if(true(),x,y) -> x
              if(false(),x,y) -> y
            Restore Modifier:
             DPs:
              plus#(s(x),y) -> plus#(x,y)
             TRS:
              minus(x,0()) -> x
              minus(s(x),s(y)) -> minus(x,y)
              quot(0(),s(y)) -> 0()
              quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
              plus(0(),y) -> y
              plus(s(x),y) -> s(plus(x,y))
              minus(minus(x,y),z) -> minus(x,plus(y,z))
              app(nil(),k) -> k
              app(l,nil()) -> l
              app(cons(x,l),k) -> cons(x,app(l,k))
              sum(cons(x,nil())) -> cons(x,nil())
              sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
              sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
              plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
              plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
              plus(zero(),y) -> y
              plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
              id(x) -> x
              if(true(),x,y) -> x
              if(false(),x,y) -> y
              not(x) -> if(x,false(),true())
              gt(s(x),zero()) -> true()
              gt(zero(),y) -> false()
              gt(s(x),s(y)) -> gt(x,y)
             Size-Change Termination Processor:
              DPs:
               
              TRS:
               minus(x,0()) -> x
               minus(s(x),s(y)) -> minus(x,y)
               quot(0(),s(y)) -> 0()
               quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
               plus(0(),y) -> y
               plus(s(x),y) -> s(plus(x,y))
               minus(minus(x,y),z) -> minus(x,plus(y,z))
               app(nil(),k) -> k
               app(l,nil()) -> l
               app(cons(x,l),k) -> cons(x,app(l,k))
               sum(cons(x,nil())) -> cons(x,nil())
               sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
               sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
               plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
               plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
               plus(zero(),y) -> y
               plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
               id(x) -> x
               if(true(),x,y) -> x
               if(false(),x,y) -> y
               not(x) -> if(x,false(),true())
               gt(s(x),zero()) -> true()
               gt(zero(),y) -> false()
               gt(s(x),s(y)) -> gt(x,y)
              The DP: plus#(s(x),y) -> plus#(x,y) has the edges:
                0 >   0
                1 >=  1
              Qed
    
    DPs:
     gt#(s(x),s(y)) -> gt#(x,y)
    TRS:
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     minus(minus(x,y),z) -> minus(x,plus(y,z))
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
     sum(cons(x,nil())) -> cons(x,nil())
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
    Subterm Criterion Processor:
     simple projection:
      pi(gt#) = 0
     problem:
      DPs:
       
      TRS:
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(minus(x,y),s(y)))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       minus(minus(x,y),z) -> minus(x,plus(y,z))
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
     Qed