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


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


YES

Problem:
 0(#()) -> #()
 +(x,#()) -> x
 +(#(),x) -> x
 +(0(x),0(y)) -> 0(+(x,y))
 +(0(x),1(y)) -> 1(+(x,y))
 +(1(x),0(y)) -> 1(+(x,y))
 +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
 +(+(x,y),z) -> +(x,+(y,z))
 -(#(),x) -> #()
 -(x,#()) -> x
 -(0(x),0(y)) -> 0(-(x,y))
 -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
 -(1(x),0(y)) -> 1(-(x,y))
 -(1(x),1(y)) -> 0(-(x,y))
 not(true()) -> false()
 not(false()) -> true()
 if(true(),x,y) -> x
 if(false(),x,y) -> y
 eq(#(),#()) -> true()
 eq(#(),1(y)) -> false()
 eq(1(x),#()) -> false()
 eq(#(),0(y)) -> eq(#(),y)
 eq(0(x),#()) -> eq(x,#())
 eq(1(x),1(y)) -> eq(x,y)
 eq(0(x),1(y)) -> false()
 eq(1(x),0(y)) -> false()
 eq(0(x),0(y)) -> eq(x,y)
 ge(0(x),0(y)) -> ge(x,y)
 ge(0(x),1(y)) -> not(ge(y,x))
 ge(1(x),0(y)) -> ge(x,y)
 ge(1(x),1(y)) -> ge(x,y)
 ge(x,#()) -> true()
 ge(#(),0(x)) -> ge(#(),x)
 ge(#(),1(x)) -> false()
 log(x) -> -(log'(x),1(#()))
 log'(#()) -> #()
 log'(1(x)) -> +(log'(x),1(#()))
 log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
 *(#(),x) -> #()
 *(0(x),y) -> 0(*(x,y))
 *(1(x),y) -> +(0(*(x,y)),y)
 *(*(x,y),z) -> *(x,*(y,z))
 *(x,+(y,z)) -> +(*(x,y),*(x,z))
 app(nil(),l) -> l
 app(cons(x,l1),l2) -> cons(x,app(l1,l2))
 sum(nil()) -> 0(#())
 sum(cons(x,l)) -> +(x,sum(l))
 sum(app(l1,l2)) -> +(sum(l1),sum(l2))
 prod(nil()) -> 1(#())
 prod(cons(x,l)) -> *(x,prod(l))
 prod(app(l1,l2)) -> *(prod(l1),prod(l2))
 mem(x,nil()) -> false()
 mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
 inter(x,nil()) -> nil()
 inter(nil(),x) -> nil()
 inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
 inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
 inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
 inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
 ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
 ifinter(false(),x,l1,l2) -> inter(l1,l2)

Proof:
 DP Processor:
  DPs:
   +#(0(x),0(y)) -> +#(x,y)
   +#(0(x),0(y)) -> 0#(+(x,y))
   +#(0(x),1(y)) -> +#(x,y)
   +#(1(x),0(y)) -> +#(x,y)
   +#(1(x),1(y)) -> +#(x,y)
   +#(1(x),1(y)) -> +#(+(x,y),1(#()))
   +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
   +#(+(x,y),z) -> +#(y,z)
   +#(+(x,y),z) -> +#(x,+(y,z))
   -#(0(x),0(y)) -> -#(x,y)
   -#(0(x),0(y)) -> 0#(-(x,y))
   -#(0(x),1(y)) -> -#(x,y)
   -#(0(x),1(y)) -> -#(-(x,y),1(#()))
   -#(1(x),0(y)) -> -#(x,y)
   -#(1(x),1(y)) -> -#(x,y)
   -#(1(x),1(y)) -> 0#(-(x,y))
   eq#(#(),0(y)) -> eq#(#(),y)
   eq#(0(x),#()) -> eq#(x,#())
   eq#(1(x),1(y)) -> eq#(x,y)
   eq#(0(x),0(y)) -> eq#(x,y)
   ge#(0(x),0(y)) -> ge#(x,y)
   ge#(0(x),1(y)) -> ge#(y,x)
   ge#(0(x),1(y)) -> not#(ge(y,x))
   ge#(1(x),0(y)) -> ge#(x,y)
   ge#(1(x),1(y)) -> ge#(x,y)
   ge#(#(),0(x)) -> ge#(#(),x)
   log#(x) -> log'#(x)
   log#(x) -> -#(log'(x),1(#()))
   log'#(1(x)) -> log'#(x)
   log'#(1(x)) -> +#(log'(x),1(#()))
   log'#(0(x)) -> log'#(x)
   log'#(0(x)) -> +#(log'(x),1(#()))
   log'#(0(x)) -> ge#(x,1(#()))
   log'#(0(x)) -> if#(ge(x,1(#())),+(log'(x),1(#())),#())
   *#(0(x),y) -> *#(x,y)
   *#(0(x),y) -> 0#(*(x,y))
   *#(1(x),y) -> *#(x,y)
   *#(1(x),y) -> 0#(*(x,y))
   *#(1(x),y) -> +#(0(*(x,y)),y)
   *#(*(x,y),z) -> *#(y,z)
   *#(*(x,y),z) -> *#(x,*(y,z))
   *#(x,+(y,z)) -> *#(x,z)
   *#(x,+(y,z)) -> *#(x,y)
   *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
   app#(cons(x,l1),l2) -> app#(l1,l2)
   sum#(nil()) -> 0#(#())
   sum#(cons(x,l)) -> sum#(l)
   sum#(cons(x,l)) -> +#(x,sum(l))
   sum#(app(l1,l2)) -> sum#(l2)
   sum#(app(l1,l2)) -> sum#(l1)
   sum#(app(l1,l2)) -> +#(sum(l1),sum(l2))
   prod#(cons(x,l)) -> prod#(l)
   prod#(cons(x,l)) -> *#(x,prod(l))
   prod#(app(l1,l2)) -> prod#(l2)
   prod#(app(l1,l2)) -> prod#(l1)
   prod#(app(l1,l2)) -> *#(prod(l1),prod(l2))
   mem#(x,cons(y,l)) -> mem#(x,l)
   mem#(x,cons(y,l)) -> eq#(x,y)
   mem#(x,cons(y,l)) -> if#(eq(x,y),true(),mem(x,l))
   inter#(app(l1,l2),l3) -> inter#(l2,l3)
   inter#(app(l1,l2),l3) -> inter#(l1,l3)
   inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
   inter#(l1,app(l2,l3)) -> inter#(l1,l3)
   inter#(l1,app(l2,l3)) -> inter#(l1,l2)
   inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
   inter#(cons(x,l1),l2) -> mem#(x,l2)
   inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
   inter#(l1,cons(x,l2)) -> mem#(x,l1)
   inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
   ifinter#(true(),x,l1,l2) -> inter#(l1,l2)
   ifinter#(false(),x,l1,l2) -> inter#(l1,l2)
  TRS:
   0(#()) -> #()
   +(x,#()) -> x
   +(#(),x) -> x
   +(0(x),0(y)) -> 0(+(x,y))
   +(0(x),1(y)) -> 1(+(x,y))
   +(1(x),0(y)) -> 1(+(x,y))
   +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
   +(+(x,y),z) -> +(x,+(y,z))
   -(#(),x) -> #()
   -(x,#()) -> x
   -(0(x),0(y)) -> 0(-(x,y))
   -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
   -(1(x),0(y)) -> 1(-(x,y))
   -(1(x),1(y)) -> 0(-(x,y))
   not(true()) -> false()
   not(false()) -> true()
   if(true(),x,y) -> x
   if(false(),x,y) -> y
   eq(#(),#()) -> true()
   eq(#(),1(y)) -> false()
   eq(1(x),#()) -> false()
   eq(#(),0(y)) -> eq(#(),y)
   eq(0(x),#()) -> eq(x,#())
   eq(1(x),1(y)) -> eq(x,y)
   eq(0(x),1(y)) -> false()
   eq(1(x),0(y)) -> false()
   eq(0(x),0(y)) -> eq(x,y)
   ge(0(x),0(y)) -> ge(x,y)
   ge(0(x),1(y)) -> not(ge(y,x))
   ge(1(x),0(y)) -> ge(x,y)
   ge(1(x),1(y)) -> ge(x,y)
   ge(x,#()) -> true()
   ge(#(),0(x)) -> ge(#(),x)
   ge(#(),1(x)) -> false()
   log(x) -> -(log'(x),1(#()))
   log'(#()) -> #()
   log'(1(x)) -> +(log'(x),1(#()))
   log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
   *(#(),x) -> #()
   *(0(x),y) -> 0(*(x,y))
   *(1(x),y) -> +(0(*(x,y)),y)
   *(*(x,y),z) -> *(x,*(y,z))
   *(x,+(y,z)) -> +(*(x,y),*(x,z))
   app(nil(),l) -> l
   app(cons(x,l1),l2) -> cons(x,app(l1,l2))
   sum(nil()) -> 0(#())
   sum(cons(x,l)) -> +(x,sum(l))
   sum(app(l1,l2)) -> +(sum(l1),sum(l2))
   prod(nil()) -> 1(#())
   prod(cons(x,l)) -> *(x,prod(l))
   prod(app(l1,l2)) -> *(prod(l1),prod(l2))
   mem(x,nil()) -> false()
   mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
   inter(x,nil()) -> nil()
   inter(nil(),x) -> nil()
   inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
   inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
   inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
   inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
   ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
   ifinter(false(),x,l1,l2) -> inter(l1,l2)
  TDG Processor:
   DPs:
    +#(0(x),0(y)) -> +#(x,y)
    +#(0(x),0(y)) -> 0#(+(x,y))
    +#(0(x),1(y)) -> +#(x,y)
    +#(1(x),0(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(+(x,y),z) -> +#(y,z)
    +#(+(x,y),z) -> +#(x,+(y,z))
    -#(0(x),0(y)) -> -#(x,y)
    -#(0(x),0(y)) -> 0#(-(x,y))
    -#(0(x),1(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    -#(1(x),0(y)) -> -#(x,y)
    -#(1(x),1(y)) -> -#(x,y)
    -#(1(x),1(y)) -> 0#(-(x,y))
    eq#(#(),0(y)) -> eq#(#(),y)
    eq#(0(x),#()) -> eq#(x,#())
    eq#(1(x),1(y)) -> eq#(x,y)
    eq#(0(x),0(y)) -> eq#(x,y)
    ge#(0(x),0(y)) -> ge#(x,y)
    ge#(0(x),1(y)) -> ge#(y,x)
    ge#(0(x),1(y)) -> not#(ge(y,x))
    ge#(1(x),0(y)) -> ge#(x,y)
    ge#(1(x),1(y)) -> ge#(x,y)
    ge#(#(),0(x)) -> ge#(#(),x)
    log#(x) -> log'#(x)
    log#(x) -> -#(log'(x),1(#()))
    log'#(1(x)) -> log'#(x)
    log'#(1(x)) -> +#(log'(x),1(#()))
    log'#(0(x)) -> log'#(x)
    log'#(0(x)) -> +#(log'(x),1(#()))
    log'#(0(x)) -> ge#(x,1(#()))
    log'#(0(x)) -> if#(ge(x,1(#())),+(log'(x),1(#())),#())
    *#(0(x),y) -> *#(x,y)
    *#(0(x),y) -> 0#(*(x,y))
    *#(1(x),y) -> *#(x,y)
    *#(1(x),y) -> 0#(*(x,y))
    *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(*(x,y),z) -> *#(y,z)
    *#(*(x,y),z) -> *#(x,*(y,z))
    *#(x,+(y,z)) -> *#(x,z)
    *#(x,+(y,z)) -> *#(x,y)
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    app#(cons(x,l1),l2) -> app#(l1,l2)
    sum#(nil()) -> 0#(#())
    sum#(cons(x,l)) -> sum#(l)
    sum#(cons(x,l)) -> +#(x,sum(l))
    sum#(app(l1,l2)) -> sum#(l2)
    sum#(app(l1,l2)) -> sum#(l1)
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2))
    prod#(cons(x,l)) -> prod#(l)
    prod#(cons(x,l)) -> *#(x,prod(l))
    prod#(app(l1,l2)) -> prod#(l2)
    prod#(app(l1,l2)) -> prod#(l1)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2))
    mem#(x,cons(y,l)) -> mem#(x,l)
    mem#(x,cons(y,l)) -> eq#(x,y)
    mem#(x,cons(y,l)) -> if#(eq(x,y),true(),mem(x,l))
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2)
   TRS:
    0(#()) -> #()
    +(x,#()) -> x
    +(#(),x) -> x
    +(0(x),0(y)) -> 0(+(x,y))
    +(0(x),1(y)) -> 1(+(x,y))
    +(1(x),0(y)) -> 1(+(x,y))
    +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
    +(+(x,y),z) -> +(x,+(y,z))
    -(#(),x) -> #()
    -(x,#()) -> x
    -(0(x),0(y)) -> 0(-(x,y))
    -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
    -(1(x),0(y)) -> 1(-(x,y))
    -(1(x),1(y)) -> 0(-(x,y))
    not(true()) -> false()
    not(false()) -> true()
    if(true(),x,y) -> x
    if(false(),x,y) -> y
    eq(#(),#()) -> true()
    eq(#(),1(y)) -> false()
    eq(1(x),#()) -> false()
    eq(#(),0(y)) -> eq(#(),y)
    eq(0(x),#()) -> eq(x,#())
    eq(1(x),1(y)) -> eq(x,y)
    eq(0(x),1(y)) -> false()
    eq(1(x),0(y)) -> false()
    eq(0(x),0(y)) -> eq(x,y)
    ge(0(x),0(y)) -> ge(x,y)
    ge(0(x),1(y)) -> not(ge(y,x))
    ge(1(x),0(y)) -> ge(x,y)
    ge(1(x),1(y)) -> ge(x,y)
    ge(x,#()) -> true()
    ge(#(),0(x)) -> ge(#(),x)
    ge(#(),1(x)) -> false()
    log(x) -> -(log'(x),1(#()))
    log'(#()) -> #()
    log'(1(x)) -> +(log'(x),1(#()))
    log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
    *(#(),x) -> #()
    *(0(x),y) -> 0(*(x,y))
    *(1(x),y) -> +(0(*(x,y)),y)
    *(*(x,y),z) -> *(x,*(y,z))
    *(x,+(y,z)) -> +(*(x,y),*(x,z))
    app(nil(),l) -> l
    app(cons(x,l1),l2) -> cons(x,app(l1,l2))
    sum(nil()) -> 0(#())
    sum(cons(x,l)) -> +(x,sum(l))
    sum(app(l1,l2)) -> +(sum(l1),sum(l2))
    prod(nil()) -> 1(#())
    prod(cons(x,l)) -> *(x,prod(l))
    prod(app(l1,l2)) -> *(prod(l1),prod(l2))
    mem(x,nil()) -> false()
    mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
    inter(x,nil()) -> nil()
    inter(nil(),x) -> nil()
    inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
    inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
    inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
    inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
    ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
    ifinter(false(),x,l1,l2) -> inter(l1,l2)
   graph:
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2) ->
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2)
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2) ->
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2)
    inter#(cons(x,l1),l2) -> mem#(x,l2) ->
    mem#(x,cons(y,l)) -> if#(eq(x,y),true(),mem(x,l))
    inter#(cons(x,l1),l2) -> mem#(x,l2) ->
    mem#(x,cons(y,l)) -> eq#(x,y)
    inter#(cons(x,l1),l2) -> mem#(x,l2) ->
    mem#(x,cons(y,l)) -> mem#(x,l)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    inter#(app(l1,l2),l3) -> inter#(l2,l3) ->
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    inter#(app(l1,l2),l3) -> inter#(l1,l3) ->
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3)) ->
    app#(cons(x,l1),l2) -> app#(l1,l2)
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1) ->
    ifinter#(false(),x,l1,l2) -> inter#(l1,l2)
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1) ->
    ifinter#(true(),x,l1,l2) -> inter#(l1,l2)
    inter#(l1,cons(x,l2)) -> mem#(x,l1) ->
    mem#(x,cons(y,l)) -> if#(eq(x,y),true(),mem(x,l))
    inter#(l1,cons(x,l2)) -> mem#(x,l1) ->
    mem#(x,cons(y,l)) -> eq#(x,y)
    inter#(l1,cons(x,l2)) -> mem#(x,l1) ->
    mem#(x,cons(y,l)) -> mem#(x,l)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    inter#(l1,app(l2,l3)) -> inter#(l1,l3) ->
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(l1,cons(x,l2)) -> mem#(x,l1)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(cons(x,l1),l2) -> mem#(x,l2)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3))
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l2)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(l1,app(l2,l3)) -> inter#(l1,l3)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> app#(inter(l1,l3),inter(l2,l3))
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> inter#(l1,l3)
    inter#(l1,app(l2,l3)) -> inter#(l1,l2) ->
    inter#(app(l1,l2),l3) -> inter#(l2,l3)
    inter#(l1,app(l2,l3)) -> app#(inter(l1,l2),inter(l1,l3)) ->
    app#(cons(x,l1),l2) -> app#(l1,l2)
    mem#(x,cons(y,l)) -> mem#(x,l) ->
    mem#(x,cons(y,l)) -> if#(eq(x,y),true(),mem(x,l))
    mem#(x,cons(y,l)) -> mem#(x,l) -> mem#(x,cons(y,l)) -> eq#(x,y)
    mem#(x,cons(y,l)) -> mem#(x,l) -> mem#(x,cons(y,l)) -> mem#(x,l)
    mem#(x,cons(y,l)) -> eq#(x,y) -> eq#(0(x),0(y)) -> eq#(x,y)
    mem#(x,cons(y,l)) -> eq#(x,y) -> eq#(1(x),1(y)) -> eq#(x,y)
    mem#(x,cons(y,l)) -> eq#(x,y) -> eq#(0(x),#()) -> eq#(x,#())
    mem#(x,cons(y,l)) -> eq#(x,y) -> eq#(#(),0(y)) -> eq#(#(),y)
    prod#(cons(x,l)) -> prod#(l) ->
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2))
    prod#(cons(x,l)) -> prod#(l) -> prod#(app(l1,l2)) -> prod#(l1)
    prod#(cons(x,l)) -> prod#(l) -> prod#(app(l1,l2)) -> prod#(l2)
    prod#(cons(x,l)) -> prod#(l) -> prod#(cons(x,l)) -> *#(x,prod(l))
    prod#(cons(x,l)) -> prod#(l) -> prod#(cons(x,l)) -> prod#(l)
    prod#(cons(x,l)) -> *#(x,prod(l)) ->
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(x,+(y,z)) -> *#(x,y)
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(x,+(y,z)) -> *#(x,z)
    prod#(cons(x,l)) -> *#(x,prod(l)) ->
    *#(*(x,y),z) -> *#(x,*(y,z))
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(*(x,y),z) -> *#(y,z)
    prod#(cons(x,l)) -> *#(x,prod(l)) ->
    *#(1(x),y) -> +#(0(*(x,y)),y)
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(1(x),y) -> 0#(*(x,y))
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(1(x),y) -> *#(x,y)
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(0(x),y) -> 0#(*(x,y))
    prod#(cons(x,l)) -> *#(x,prod(l)) -> *#(0(x),y) -> *#(x,y)
    prod#(app(l1,l2)) -> prod#(l2) ->
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2))
    prod#(app(l1,l2)) -> prod#(l2) -> prod#(app(l1,l2)) -> prod#(l1)
    prod#(app(l1,l2)) -> prod#(l2) -> prod#(app(l1,l2)) -> prod#(l2)
    prod#(app(l1,l2)) -> prod#(l2) ->
    prod#(cons(x,l)) -> *#(x,prod(l))
    prod#(app(l1,l2)) -> prod#(l2) -> prod#(cons(x,l)) -> prod#(l)
    prod#(app(l1,l2)) -> prod#(l1) ->
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2))
    prod#(app(l1,l2)) -> prod#(l1) -> prod#(app(l1,l2)) -> prod#(l1)
    prod#(app(l1,l2)) -> prod#(l1) -> prod#(app(l1,l2)) -> prod#(l2)
    prod#(app(l1,l2)) -> prod#(l1) ->
    prod#(cons(x,l)) -> *#(x,prod(l))
    prod#(app(l1,l2)) -> prod#(l1) ->
    prod#(cons(x,l)) -> prod#(l)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(x,+(y,z)) -> *#(x,y)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(x,+(y,z)) -> *#(x,z)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(*(x,y),z) -> *#(x,*(y,z))
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(*(x,y),z) -> *#(y,z)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(1(x),y) -> +#(0(*(x,y)),y)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(1(x),y) -> 0#(*(x,y))
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(1(x),y) -> *#(x,y)
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) ->
    *#(0(x),y) -> 0#(*(x,y))
    prod#(app(l1,l2)) -> *#(prod(l1),prod(l2)) -> *#(0(x),y) -> *#(x,y)
    sum#(cons(x,l)) -> sum#(l) -> sum#(app(l1,l2)) -> +#(sum(l1),sum(l2))
    sum#(cons(x,l)) -> sum#(l) -> sum#(app(l1,l2)) -> sum#(l1)
    sum#(cons(x,l)) -> sum#(l) -> sum#(app(l1,l2)) -> sum#(l2)
    sum#(cons(x,l)) -> sum#(l) -> sum#(cons(x,l)) -> +#(x,sum(l))
    sum#(cons(x,l)) -> sum#(l) -> sum#(cons(x,l)) -> sum#(l)
    sum#(cons(x,l)) -> sum#(l) -> sum#(nil()) -> 0#(#())
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(+(x,y),z) -> +#(x,+(y,z))
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(+(x,y),z) -> +#(y,z)
    sum#(cons(x,l)) -> +#(x,sum(l)) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    sum#(cons(x,l)) -> +#(x,sum(l)) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(1(x),1(y)) -> +#(x,y)
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(1(x),0(y)) -> +#(x,y)
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(0(x),1(y)) -> +#(x,y)
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(0(x),0(y)) -> 0#(+(x,y))
    sum#(cons(x,l)) -> +#(x,sum(l)) -> +#(0(x),0(y)) -> +#(x,y)
    sum#(app(l1,l2)) -> sum#(l2) ->
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2))
    sum#(app(l1,l2)) -> sum#(l2) -> sum#(app(l1,l2)) -> sum#(l1)
    sum#(app(l1,l2)) -> sum#(l2) -> sum#(app(l1,l2)) -> sum#(l2)
    sum#(app(l1,l2)) -> sum#(l2) -> sum#(cons(x,l)) -> +#(x,sum(l))
    sum#(app(l1,l2)) -> sum#(l2) -> sum#(cons(x,l)) -> sum#(l)
    sum#(app(l1,l2)) -> sum#(l2) -> sum#(nil()) -> 0#(#())
    sum#(app(l1,l2)) -> sum#(l1) ->
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2))
    sum#(app(l1,l2)) -> sum#(l1) -> sum#(app(l1,l2)) -> sum#(l1)
    sum#(app(l1,l2)) -> sum#(l1) -> sum#(app(l1,l2)) -> sum#(l2)
    sum#(app(l1,l2)) -> sum#(l1) -> sum#(cons(x,l)) -> +#(x,sum(l))
    sum#(app(l1,l2)) -> sum#(l1) -> sum#(cons(x,l)) -> sum#(l)
    sum#(app(l1,l2)) -> sum#(l1) -> sum#(nil()) -> 0#(#())
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(+(x,y),z) -> +#(x,+(y,z))
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(+(x,y),z) -> +#(y,z)
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(1(x),1(y)) -> +#(x,y)
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(1(x),0(y)) -> +#(x,y)
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(0(x),1(y)) -> +#(x,y)
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(0(x),0(y)) -> 0#(+(x,y))
    sum#(app(l1,l2)) -> +#(sum(l1),sum(l2)) ->
    +#(0(x),0(y)) -> +#(x,y)
    app#(cons(x,l1),l2) -> app#(l1,l2) -> app#(cons(x,l1),l2) -> app#(l1,l2)
    *#(*(x,y),z) -> *#(y,z) -> *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    *#(*(x,y),z) -> *#(y,z) -> *#(x,+(y,z)) -> *#(x,y)
    *#(*(x,y),z) -> *#(y,z) -> *#(x,+(y,z)) -> *#(x,z)
    *#(*(x,y),z) -> *#(y,z) -> *#(*(x,y),z) -> *#(x,*(y,z))
    *#(*(x,y),z) -> *#(y,z) -> *#(*(x,y),z) -> *#(y,z)
    *#(*(x,y),z) -> *#(y,z) -> *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(*(x,y),z) -> *#(y,z) -> *#(1(x),y) -> 0#(*(x,y))
    *#(*(x,y),z) -> *#(y,z) -> *#(1(x),y) -> *#(x,y)
    *#(*(x,y),z) -> *#(y,z) -> *#(0(x),y) -> 0#(*(x,y))
    *#(*(x,y),z) -> *#(y,z) -> *#(0(x),y) -> *#(x,y)
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(x,+(y,z)) -> *#(x,y)
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(x,+(y,z)) -> *#(x,z)
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(*(x,y),z) -> *#(x,*(y,z))
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(*(x,y),z) -> *#(y,z)
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(1(x),y) -> 0#(*(x,y))
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(1(x),y) -> *#(x,y)
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(0(x),y) -> 0#(*(x,y))
    *#(*(x,y),z) -> *#(x,*(y,z)) -> *#(0(x),y) -> *#(x,y)
    *#(1(x),y) -> *#(x,y) -> *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    *#(1(x),y) -> *#(x,y) -> *#(x,+(y,z)) -> *#(x,y)
    *#(1(x),y) -> *#(x,y) -> *#(x,+(y,z)) -> *#(x,z)
    *#(1(x),y) -> *#(x,y) -> *#(*(x,y),z) -> *#(x,*(y,z))
    *#(1(x),y) -> *#(x,y) -> *#(*(x,y),z) -> *#(y,z)
    *#(1(x),y) -> *#(x,y) -> *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(1(x),y) -> *#(x,y) -> *#(1(x),y) -> 0#(*(x,y))
    *#(1(x),y) -> *#(x,y) -> *#(1(x),y) -> *#(x,y)
    *#(1(x),y) -> *#(x,y) -> *#(0(x),y) -> 0#(*(x,y))
    *#(1(x),y) -> *#(x,y) -> *#(0(x),y) -> *#(x,y)
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(+(x,y),z) -> +#(x,+(y,z))
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(+(x,y),z) -> +#(y,z)
    *#(1(x),y) -> +#(0(*(x,y)),y) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    *#(1(x),y) -> +#(0(*(x,y)),y) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(1(x),1(y)) -> +#(x,y)
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(1(x),0(y)) -> +#(x,y)
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(0(x),1(y)) -> +#(x,y)
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(0(x),0(y)) -> 0#(+(x,y))
    *#(1(x),y) -> +#(0(*(x,y)),y) -> +#(0(x),0(y)) -> +#(x,y)
    *#(0(x),y) -> *#(x,y) -> *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    *#(0(x),y) -> *#(x,y) -> *#(x,+(y,z)) -> *#(x,y)
    *#(0(x),y) -> *#(x,y) -> *#(x,+(y,z)) -> *#(x,z)
    *#(0(x),y) -> *#(x,y) -> *#(*(x,y),z) -> *#(x,*(y,z))
    *#(0(x),y) -> *#(x,y) -> *#(*(x,y),z) -> *#(y,z)
    *#(0(x),y) -> *#(x,y) -> *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(0(x),y) -> *#(x,y) -> *#(1(x),y) -> 0#(*(x,y))
    *#(0(x),y) -> *#(x,y) -> *#(1(x),y) -> *#(x,y)
    *#(0(x),y) -> *#(x,y) -> *#(0(x),y) -> 0#(*(x,y))
    *#(0(x),y) -> *#(x,y) -> *#(0(x),y) -> *#(x,y)
    *#(x,+(y,z)) -> *#(x,z) -> *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    *#(x,+(y,z)) -> *#(x,z) -> *#(x,+(y,z)) -> *#(x,y)
    *#(x,+(y,z)) -> *#(x,z) -> *#(x,+(y,z)) -> *#(x,z)
    *#(x,+(y,z)) -> *#(x,z) -> *#(*(x,y),z) -> *#(x,*(y,z))
    *#(x,+(y,z)) -> *#(x,z) -> *#(*(x,y),z) -> *#(y,z)
    *#(x,+(y,z)) -> *#(x,z) -> *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(x,+(y,z)) -> *#(x,z) -> *#(1(x),y) -> 0#(*(x,y))
    *#(x,+(y,z)) -> *#(x,z) -> *#(1(x),y) -> *#(x,y)
    *#(x,+(y,z)) -> *#(x,z) -> *#(0(x),y) -> 0#(*(x,y))
    *#(x,+(y,z)) -> *#(x,z) -> *#(0(x),y) -> *#(x,y)
    *#(x,+(y,z)) -> *#(x,y) -> *#(x,+(y,z)) -> +#(*(x,y),*(x,z))
    *#(x,+(y,z)) -> *#(x,y) -> *#(x,+(y,z)) -> *#(x,y)
    *#(x,+(y,z)) -> *#(x,y) -> *#(x,+(y,z)) -> *#(x,z)
    *#(x,+(y,z)) -> *#(x,y) -> *#(*(x,y),z) -> *#(x,*(y,z))
    *#(x,+(y,z)) -> *#(x,y) -> *#(*(x,y),z) -> *#(y,z)
    *#(x,+(y,z)) -> *#(x,y) -> *#(1(x),y) -> +#(0(*(x,y)),y)
    *#(x,+(y,z)) -> *#(x,y) -> *#(1(x),y) -> 0#(*(x,y))
    *#(x,+(y,z)) -> *#(x,y) -> *#(1(x),y) -> *#(x,y)
    *#(x,+(y,z)) -> *#(x,y) -> *#(0(x),y) -> 0#(*(x,y))
    *#(x,+(y,z)) -> *#(x,y) -> *#(0(x),y) -> *#(x,y)
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) ->
    +#(+(x,y),z) -> +#(x,+(y,z))
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) -> +#(+(x,y),z) -> +#(y,z)
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) -> +#(1(x),1(y)) -> +#(x,y)
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) -> +#(1(x),0(y)) -> +#(x,y)
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) -> +#(0(x),1(y)) -> +#(x,y)
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) ->
    +#(0(x),0(y)) -> 0#(+(x,y))
    *#(x,+(y,z)) -> +#(*(x,y),*(x,z)) -> +#(0(x),0(y)) -> +#(x,y)
    log'#(1(x)) -> log'#(x) ->
    log'#(0(x)) -> if#(ge(x,1(#())),+(log'(x),1(#())),#())
    log'#(1(x)) -> log'#(x) -> log'#(0(x)) -> ge#(x,1(#()))
    log'#(1(x)) -> log'#(x) -> log'#(0(x)) -> +#(log'(x),1(#()))
    log'#(1(x)) -> log'#(x) -> log'#(0(x)) -> log'#(x)
    log'#(1(x)) -> log'#(x) -> log'#(1(x)) -> +#(log'(x),1(#()))
    log'#(1(x)) -> log'#(x) -> log'#(1(x)) -> log'#(x)
    log'#(1(x)) -> +#(log'(x),1(#())) ->
    +#(+(x,y),z) -> +#(x,+(y,z))
    log'#(1(x)) -> +#(log'(x),1(#())) -> +#(+(x,y),z) -> +#(y,z)
    log'#(1(x)) -> +#(log'(x),1(#())) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    log'#(1(x)) -> +#(log'(x),1(#())) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    log'#(1(x)) -> +#(log'(x),1(#())) -> +#(1(x),1(y)) -> +#(x,y)
    log'#(1(x)) -> +#(log'(x),1(#())) -> +#(1(x),0(y)) -> +#(x,y)
    log'#(1(x)) -> +#(log'(x),1(#())) -> +#(0(x),1(y)) -> +#(x,y)
    log'#(1(x)) -> +#(log'(x),1(#())) ->
    +#(0(x),0(y)) -> 0#(+(x,y))
    log'#(1(x)) -> +#(log'(x),1(#())) -> +#(0(x),0(y)) -> +#(x,y)
    log'#(0(x)) -> log'#(x) ->
    log'#(0(x)) -> if#(ge(x,1(#())),+(log'(x),1(#())),#())
    log'#(0(x)) -> log'#(x) -> log'#(0(x)) -> ge#(x,1(#()))
    log'#(0(x)) -> log'#(x) -> log'#(0(x)) -> +#(log'(x),1(#()))
    log'#(0(x)) -> log'#(x) -> log'#(0(x)) -> log'#(x)
    log'#(0(x)) -> log'#(x) -> log'#(1(x)) -> +#(log'(x),1(#()))
    log'#(0(x)) -> log'#(x) -> log'#(1(x)) -> log'#(x)
    log'#(0(x)) -> ge#(x,1(#())) -> ge#(#(),0(x)) -> ge#(#(),x)
    log'#(0(x)) -> ge#(x,1(#())) -> ge#(1(x),1(y)) -> ge#(x,y)
    log'#(0(x)) -> ge#(x,1(#())) -> ge#(1(x),0(y)) -> ge#(x,y)
    log'#(0(x)) -> ge#(x,1(#())) -> ge#(0(x),1(y)) -> not#(ge(y,x))
    log'#(0(x)) -> ge#(x,1(#())) -> ge#(0(x),1(y)) -> ge#(y,x)
    log'#(0(x)) -> ge#(x,1(#())) -> ge#(0(x),0(y)) -> ge#(x,y)
    log'#(0(x)) -> +#(log'(x),1(#())) ->
    +#(+(x,y),z) -> +#(x,+(y,z))
    log'#(0(x)) -> +#(log'(x),1(#())) -> +#(+(x,y),z) -> +#(y,z)
    log'#(0(x)) -> +#(log'(x),1(#())) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    log'#(0(x)) -> +#(log'(x),1(#())) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    log'#(0(x)) -> +#(log'(x),1(#())) -> +#(1(x),1(y)) -> +#(x,y)
    log'#(0(x)) -> +#(log'(x),1(#())) -> +#(1(x),0(y)) -> +#(x,y)
    log'#(0(x)) -> +#(log'(x),1(#())) -> +#(0(x),1(y)) -> +#(x,y)
    log'#(0(x)) -> +#(log'(x),1(#())) ->
    +#(0(x),0(y)) -> 0#(+(x,y))
    log'#(0(x)) -> +#(log'(x),1(#())) -> +#(0(x),0(y)) -> +#(x,y)
    log#(x) -> log'#(x) ->
    log'#(0(x)) -> if#(ge(x,1(#())),+(log'(x),1(#())),#())
    log#(x) -> log'#(x) -> log'#(0(x)) -> ge#(x,1(#()))
    log#(x) -> log'#(x) -> log'#(0(x)) -> +#(log'(x),1(#()))
    log#(x) -> log'#(x) -> log'#(0(x)) -> log'#(x)
    log#(x) -> log'#(x) -> log'#(1(x)) -> +#(log'(x),1(#()))
    log#(x) -> log'#(x) -> log'#(1(x)) -> log'#(x)
    log#(x) -> -#(log'(x),1(#())) -> -#(1(x),1(y)) -> 0#(-(x,y))
    log#(x) -> -#(log'(x),1(#())) -> -#(1(x),1(y)) -> -#(x,y)
    log#(x) -> -#(log'(x),1(#())) -> -#(1(x),0(y)) -> -#(x,y)
    log#(x) -> -#(log'(x),1(#())) ->
    -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    log#(x) -> -#(log'(x),1(#())) -> -#(0(x),1(y)) -> -#(x,y)
    log#(x) -> -#(log'(x),1(#())) -> -#(0(x),0(y)) -> 0#(-(x,y))
    log#(x) -> -#(log'(x),1(#())) -> -#(0(x),0(y)) -> -#(x,y)
    ge#(1(x),1(y)) -> ge#(x,y) -> ge#(#(),0(x)) -> ge#(#(),x)
    ge#(1(x),1(y)) -> ge#(x,y) -> ge#(1(x),1(y)) -> ge#(x,y)
    ge#(1(x),1(y)) -> ge#(x,y) -> ge#(1(x),0(y)) -> ge#(x,y)
    ge#(1(x),1(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> not#(ge(y,x))
    ge#(1(x),1(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> ge#(y,x)
    ge#(1(x),1(y)) -> ge#(x,y) -> ge#(0(x),0(y)) -> ge#(x,y)
    ge#(1(x),0(y)) -> ge#(x,y) -> ge#(#(),0(x)) -> ge#(#(),x)
    ge#(1(x),0(y)) -> ge#(x,y) -> ge#(1(x),1(y)) -> ge#(x,y)
    ge#(1(x),0(y)) -> ge#(x,y) -> ge#(1(x),0(y)) -> ge#(x,y)
    ge#(1(x),0(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> not#(ge(y,x))
    ge#(1(x),0(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> ge#(y,x)
    ge#(1(x),0(y)) -> ge#(x,y) -> ge#(0(x),0(y)) -> ge#(x,y)
    ge#(0(x),1(y)) -> ge#(y,x) -> ge#(#(),0(x)) -> ge#(#(),x)
    ge#(0(x),1(y)) -> ge#(y,x) -> ge#(1(x),1(y)) -> ge#(x,y)
    ge#(0(x),1(y)) -> ge#(y,x) -> ge#(1(x),0(y)) -> ge#(x,y)
    ge#(0(x),1(y)) -> ge#(y,x) -> ge#(0(x),1(y)) -> not#(ge(y,x))
    ge#(0(x),1(y)) -> ge#(y,x) -> ge#(0(x),1(y)) -> ge#(y,x)
    ge#(0(x),1(y)) -> ge#(y,x) -> ge#(0(x),0(y)) -> ge#(x,y)
    ge#(0(x),0(y)) -> ge#(x,y) -> ge#(#(),0(x)) -> ge#(#(),x)
    ge#(0(x),0(y)) -> ge#(x,y) -> ge#(1(x),1(y)) -> ge#(x,y)
    ge#(0(x),0(y)) -> ge#(x,y) -> ge#(1(x),0(y)) -> ge#(x,y)
    ge#(0(x),0(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> not#(ge(y,x))
    ge#(0(x),0(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> ge#(y,x)
    ge#(0(x),0(y)) -> ge#(x,y) -> ge#(0(x),0(y)) -> ge#(x,y)
    ge#(#(),0(x)) -> ge#(#(),x) -> ge#(#(),0(x)) -> ge#(#(),x)
    ge#(#(),0(x)) -> ge#(#(),x) -> ge#(1(x),1(y)) -> ge#(x,y)
    ge#(#(),0(x)) -> ge#(#(),x) -> ge#(1(x),0(y)) -> ge#(x,y)
    ge#(#(),0(x)) -> ge#(#(),x) -> ge#(0(x),1(y)) -> not#(ge(y,x))
    ge#(#(),0(x)) -> ge#(#(),x) -> ge#(0(x),1(y)) -> ge#(y,x)
    ge#(#(),0(x)) -> ge#(#(),x) -> ge#(0(x),0(y)) -> ge#(x,y)
    eq#(1(x),1(y)) -> eq#(x,y) -> eq#(0(x),0(y)) -> eq#(x,y)
    eq#(1(x),1(y)) -> eq#(x,y) -> eq#(1(x),1(y)) -> eq#(x,y)
    eq#(1(x),1(y)) -> eq#(x,y) -> eq#(0(x),#()) -> eq#(x,#())
    eq#(1(x),1(y)) -> eq#(x,y) -> eq#(#(),0(y)) -> eq#(#(),y)
    eq#(0(x),0(y)) -> eq#(x,y) -> eq#(0(x),0(y)) -> eq#(x,y)
    eq#(0(x),0(y)) -> eq#(x,y) -> eq#(1(x),1(y)) -> eq#(x,y)
    eq#(0(x),0(y)) -> eq#(x,y) -> eq#(0(x),#()) -> eq#(x,#())
    eq#(0(x),0(y)) -> eq#(x,y) -> eq#(#(),0(y)) -> eq#(#(),y)
    eq#(0(x),#()) -> eq#(x,#()) -> eq#(0(x),0(y)) -> eq#(x,y)
    eq#(0(x),#()) -> eq#(x,#()) -> eq#(1(x),1(y)) -> eq#(x,y)
    eq#(0(x),#()) -> eq#(x,#()) -> eq#(0(x),#()) -> eq#(x,#())
    eq#(0(x),#()) -> eq#(x,#()) -> eq#(#(),0(y)) -> eq#(#(),y)
    eq#(#(),0(y)) -> eq#(#(),y) -> eq#(0(x),0(y)) -> eq#(x,y)
    eq#(#(),0(y)) -> eq#(#(),y) -> eq#(1(x),1(y)) -> eq#(x,y)
    eq#(#(),0(y)) -> eq#(#(),y) -> eq#(0(x),#()) -> eq#(x,#())
    eq#(#(),0(y)) -> eq#(#(),y) -> eq#(#(),0(y)) -> eq#(#(),y)
    -#(1(x),1(y)) -> -#(x,y) -> -#(1(x),1(y)) -> 0#(-(x,y))
    -#(1(x),1(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
    -#(1(x),1(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
    -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
    -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),0(y)) -> 0#(-(x,y))
    -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
    -#(1(x),0(y)) -> -#(x,y) -> -#(1(x),1(y)) -> 0#(-(x,y))
    -#(1(x),0(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
    -#(1(x),0(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
    -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
    -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),0(y)) -> 0#(-(x,y))
    -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
    -#(1(x),1(y)) -> 0#(-(x,y))
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
    -#(1(x),1(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
    -#(1(x),0(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
    -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
    -#(0(x),1(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
    -#(0(x),0(y)) -> 0#(-(x,y))
    -#(0(x),1(y)) -> -#(-(x,y),1(#())) -> -#(0(x),0(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(x,y) -> -#(1(x),1(y)) -> 0#(-(x,y))
    -#(0(x),1(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
    -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),0(y)) -> 0#(-(x,y))
    -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
    -#(0(x),0(y)) -> -#(x,y) -> -#(1(x),1(y)) -> 0#(-(x,y))
    -#(0(x),0(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
    -#(0(x),0(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
    -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
    -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
    -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),0(y)) -> 0#(-(x,y))
    -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(+(x,y),z) -> +#(x,+(y,z))
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) -> +#(+(x,y),z) -> +#(y,z)
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(1(x),1(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(1(x),0(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(0(x),1(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
    +#(0(x),0(y)) -> 0#(+(x,y))
    +#(1(x),1(y)) -> +#(+(x,y),1(#())) -> +#(0(x),0(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
    +#(1(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
    +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
    +#(1(x),1(y)) -> +#(x,y) -> +#(0(x),0(y)) -> 0#(+(x,y))
    +#(1(x),1(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
    +#(1(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
    +#(1(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
    +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
    +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
    +#(1(x),0(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
    +#(1(x),0(y)) -> +#(x,y) -> +#(0(x),0(y)) -> 0#(+(x,y))
    +#(1(x),0(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(y,z) -> +#(+(x,y),z) -> +#(x,+(y,z))
    +#(+(x,y),z) -> +#(y,z) -> +#(+(x,y),z) -> +#(y,z)
    +#(+(x,y),z) -> +#(y,z) -> +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(+(x,y),z) -> +#(y,z) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(+(x,y),z) -> +#(y,z) -> +#(1(x),1(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(y,z) -> +#(1(x),0(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(y,z) -> +#(0(x),1(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(y,z) -> +#(0(x),0(y)) -> 0#(+(x,y))
    +#(+(x,y),z) -> +#(y,z) -> +#(0(x),0(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(+(x,y),z) -> +#(x,+(y,z))
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(+(x,y),z) -> +#(y,z)
    +#(+(x,y),z) -> +#(x,+(y,z)) ->
    +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(1(x),1(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(1(x),0(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(0(x),1(y)) -> +#(x,y)
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(0(x),0(y)) -> 0#(+(x,y))
    +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(0(x),0(y)) -> +#(x,y)
    +#(0(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
    +#(0(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
    +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
    +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
    +#(0(x),1(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
    +#(0(x),1(y)) -> +#(x,y) -> +#(0(x),0(y)) -> 0#(+(x,y))
    +#(0(x),1(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
    +#(0(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
    +#(0(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
    +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> 0#(+(+(x,y),1(#())))
    +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
    +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
    +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
    +#(0(x),0(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
    +#(0(x),0(y)) -> +#(x,y) -> +#(0(x),0(y)) -> 0#(+(x,y))
    +#(0(x),0(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
   SCC Processor:
    #sccs: 11
    #rules: 45
    #arcs: 422/5041
    DPs:
     -#(0(x),0(y)) -> -#(x,y)
     -#(0(x),1(y)) -> -#(x,y)
     -#(0(x),1(y)) -> -#(-(x,y),1(#()))
     -#(1(x),0(y)) -> -#(x,y)
     -#(1(x),1(y)) -> -#(x,y)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    EDG Processor:
     DPs:
      -#(0(x),0(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(-(x,y),1(#()))
      -#(1(x),0(y)) -> -#(x,y)
      -#(1(x),1(y)) -> -#(x,y)
     TRS:
      0(#()) -> #()
      +(x,#()) -> x
      +(#(),x) -> x
      +(0(x),0(y)) -> 0(+(x,y))
      +(0(x),1(y)) -> 1(+(x,y))
      +(1(x),0(y)) -> 1(+(x,y))
      +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
      +(+(x,y),z) -> +(x,+(y,z))
      -(#(),x) -> #()
      -(x,#()) -> x
      -(0(x),0(y)) -> 0(-(x,y))
      -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
      -(1(x),0(y)) -> 1(-(x,y))
      -(1(x),1(y)) -> 0(-(x,y))
      not(true()) -> false()
      not(false()) -> true()
      if(true(),x,y) -> x
      if(false(),x,y) -> y
      eq(#(),#()) -> true()
      eq(#(),1(y)) -> false()
      eq(1(x),#()) -> false()
      eq(#(),0(y)) -> eq(#(),y)
      eq(0(x),#()) -> eq(x,#())
      eq(1(x),1(y)) -> eq(x,y)
      eq(0(x),1(y)) -> false()
      eq(1(x),0(y)) -> false()
      eq(0(x),0(y)) -> eq(x,y)
      ge(0(x),0(y)) -> ge(x,y)
      ge(0(x),1(y)) -> not(ge(y,x))
      ge(1(x),0(y)) -> ge(x,y)
      ge(1(x),1(y)) -> ge(x,y)
      ge(x,#()) -> true()
      ge(#(),0(x)) -> ge(#(),x)
      ge(#(),1(x)) -> false()
      log(x) -> -(log'(x),1(#()))
      log'(#()) -> #()
      log'(1(x)) -> +(log'(x),1(#()))
      log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
      *(#(),x) -> #()
      *(0(x),y) -> 0(*(x,y))
      *(1(x),y) -> +(0(*(x,y)),y)
      *(*(x,y),z) -> *(x,*(y,z))
      *(x,+(y,z)) -> +(*(x,y),*(x,z))
      app(nil(),l) -> l
      app(cons(x,l1),l2) -> cons(x,app(l1,l2))
      sum(nil()) -> 0(#())
      sum(cons(x,l)) -> +(x,sum(l))
      sum(app(l1,l2)) -> +(sum(l1),sum(l2))
      prod(nil()) -> 1(#())
      prod(cons(x,l)) -> *(x,prod(l))
      prod(app(l1,l2)) -> *(prod(l1),prod(l2))
      mem(x,nil()) -> false()
      mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
      inter(x,nil()) -> nil()
      inter(nil(),x) -> nil()
      inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
      inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
      inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
      inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
      ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
      ifinter(false(),x,l1,l2) -> inter(l1,l2)
     graph:
      -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
      -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
      -#(1(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
      -#(1(x),1(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
      -#(1(x),1(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
      -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
      -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
      -#(1(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
      -#(1(x),0(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
      -#(1(x),0(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
      -#(0(x),1(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(-(x,y),1(#())) ->
      -#(0(x),1(y)) -> -#(-(x,y),1(#()))
      -#(0(x),1(y)) -> -#(-(x,y),1(#())) -> -#(1(x),1(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
      -#(0(x),1(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
      -#(0(x),1(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
      -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),0(y)) -> -#(x,y)
      -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(x,y)
      -#(0(x),0(y)) -> -#(x,y) -> -#(0(x),1(y)) -> -#(-(x,y),1(#()))
      -#(0(x),0(y)) -> -#(x,y) -> -#(1(x),0(y)) -> -#(x,y)
      -#(0(x),0(y)) -> -#(x,y) -> -#(1(x),1(y)) -> -#(x,y)
     Usable Rule Processor:
      DPs:
       -#(0(x),0(y)) -> -#(x,y)
       -#(0(x),1(y)) -> -#(x,y)
       -#(0(x),1(y)) -> -#(-(x,y),1(#()))
       -#(1(x),0(y)) -> -#(x,y)
       -#(1(x),1(y)) -> -#(x,y)
      TRS:
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       0(#()) -> #()
      Semantic Labeling Processor:
       dimension: 1
       usable rules:
        -(#(),x) -> #()
        -(x,#()) -> x
        -(0(x),0(y)) -> 0(-(x,y))
        -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
        -(1(x),0(y)) -> 1(-(x,y))
        -(1(x),1(y)) -> 0(-(x,y))
        0(#()) -> #()
       interpretation:
        [-](x0, x1) = x0,
        
        [1](x0) = x0 + 1,
        
        [0](x0) = x0 + 1,
        
        [#] = 0
        labeled:
         0
         1
         -
        usable (for model):
         0
         1
         -
         #
        argument filtering:
         pi(#) = []
         pi(0) = [0]
         pi(1) = 0
         pi(-) = [0]
         pi(-#) = 0
       precedence:
        - > -# ~ 1 ~ 0 ~ #
       problem:
        DPs:
         -#(1(x),0(y)) -> -#(x,y)
         -#(1(x),1(y)) -> -#(x,y)
        TRS:
         -(#(),x) -> #()
         -(x,#()) -> x
         -(0(x),0(y)) -> 0(-(x,y))
         -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
         -(1(x),0(y)) -> 1(-(x,y))
         -(1(x),1(y)) -> 0(-(x,y))
         0(#()) -> #()
       Restore Modifier:
        DPs:
         -#(1(x),0(y)) -> -#(x,y)
         -#(1(x),1(y)) -> -#(x,y)
        TRS:
         0(#()) -> #()
         +(x,#()) -> x
         +(#(),x) -> x
         +(0(x),0(y)) -> 0(+(x,y))
         +(0(x),1(y)) -> 1(+(x,y))
         +(1(x),0(y)) -> 1(+(x,y))
         +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
         +(+(x,y),z) -> +(x,+(y,z))
         -(#(),x) -> #()
         -(x,#()) -> x
         -(0(x),0(y)) -> 0(-(x,y))
         -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
         -(1(x),0(y)) -> 1(-(x,y))
         -(1(x),1(y)) -> 0(-(x,y))
         not(true()) -> false()
         not(false()) -> true()
         if(true(),x,y) -> x
         if(false(),x,y) -> y
         eq(#(),#()) -> true()
         eq(#(),1(y)) -> false()
         eq(1(x),#()) -> false()
         eq(#(),0(y)) -> eq(#(),y)
         eq(0(x),#()) -> eq(x,#())
         eq(1(x),1(y)) -> eq(x,y)
         eq(0(x),1(y)) -> false()
         eq(1(x),0(y)) -> false()
         eq(0(x),0(y)) -> eq(x,y)
         ge(0(x),0(y)) -> ge(x,y)
         ge(0(x),1(y)) -> not(ge(y,x))
         ge(1(x),0(y)) -> ge(x,y)
         ge(1(x),1(y)) -> ge(x,y)
         ge(x,#()) -> true()
         ge(#(),0(x)) -> ge(#(),x)
         ge(#(),1(x)) -> false()
         log(x) -> -(log'(x),1(#()))
         log'(#()) -> #()
         log'(1(x)) -> +(log'(x),1(#()))
         log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
         *(#(),x) -> #()
         *(0(x),y) -> 0(*(x,y))
         *(1(x),y) -> +(0(*(x,y)),y)
         *(*(x,y),z) -> *(x,*(y,z))
         *(x,+(y,z)) -> +(*(x,y),*(x,z))
         app(nil(),l) -> l
         app(cons(x,l1),l2) -> cons(x,app(l1,l2))
         sum(nil()) -> 0(#())
         sum(cons(x,l)) -> +(x,sum(l))
         sum(app(l1,l2)) -> +(sum(l1),sum(l2))
         prod(nil()) -> 1(#())
         prod(cons(x,l)) -> *(x,prod(l))
         prod(app(l1,l2)) -> *(prod(l1),prod(l2))
         mem(x,nil()) -> false()
         mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
         inter(x,nil()) -> nil()
         inter(nil(),x) -> nil()
         inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
         inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
         inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
         inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
         ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
         ifinter(false(),x,l1,l2) -> inter(l1,l2)
        Size-Change Termination Processor:
         DPs:
          
         TRS:
          0(#()) -> #()
          +(x,#()) -> x
          +(#(),x) -> x
          +(0(x),0(y)) -> 0(+(x,y))
          +(0(x),1(y)) -> 1(+(x,y))
          +(1(x),0(y)) -> 1(+(x,y))
          +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
          +(+(x,y),z) -> +(x,+(y,z))
          -(#(),x) -> #()
          -(x,#()) -> x
          -(0(x),0(y)) -> 0(-(x,y))
          -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
          -(1(x),0(y)) -> 1(-(x,y))
          -(1(x),1(y)) -> 0(-(x,y))
          not(true()) -> false()
          not(false()) -> true()
          if(true(),x,y) -> x
          if(false(),x,y) -> y
          eq(#(),#()) -> true()
          eq(#(),1(y)) -> false()
          eq(1(x),#()) -> false()
          eq(#(),0(y)) -> eq(#(),y)
          eq(0(x),#()) -> eq(x,#())
          eq(1(x),1(y)) -> eq(x,y)
          eq(0(x),1(y)) -> false()
          eq(1(x),0(y)) -> false()
          eq(0(x),0(y)) -> eq(x,y)
          ge(0(x),0(y)) -> ge(x,y)
          ge(0(x),1(y)) -> not(ge(y,x))
          ge(1(x),0(y)) -> ge(x,y)
          ge(1(x),1(y)) -> ge(x,y)
          ge(x,#()) -> true()
          ge(#(),0(x)) -> ge(#(),x)
          ge(#(),1(x)) -> false()
          log(x) -> -(log'(x),1(#()))
          log'(#()) -> #()
          log'(1(x)) -> +(log'(x),1(#()))
          log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
          *(#(),x) -> #()
          *(0(x),y) -> 0(*(x,y))
          *(1(x),y) -> +(0(*(x,y)),y)
          *(*(x,y),z) -> *(x,*(y,z))
          *(x,+(y,z)) -> +(*(x,y),*(x,z))
          app(nil(),l) -> l
          app(cons(x,l1),l2) -> cons(x,app(l1,l2))
          sum(nil()) -> 0(#())
          sum(cons(x,l)) -> +(x,sum(l))
          sum(app(l1,l2)) -> +(sum(l1),sum(l2))
          prod(nil()) -> 1(#())
          prod(cons(x,l)) -> *(x,prod(l))
          prod(app(l1,l2)) -> *(prod(l1),prod(l2))
          mem(x,nil()) -> false()
          mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
          inter(x,nil()) -> nil()
          inter(nil(),x) -> nil()
          inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
          inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
          inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
          inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
          ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
          ifinter(false(),x,l1,l2) -> inter(l1,l2)
         The DP: -#(1(x),0(y)) -> -#(x,y) has the edges:
           0 >   0
           1 >   1
         The DP: -#(1(x),1(y)) -> -#(x,y) has the edges:
           0 >   0
           1 >   1
         Qed
    
    DPs:
     log'#(1(x)) -> log'#(x)
     log'#(0(x)) -> log'#(x)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(log'#) = 0
     problem:
      DPs:
       
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Qed
    
    DPs:
     ge#(0(x),0(y)) -> ge#(x,y)
     ge#(0(x),1(y)) -> ge#(y,x)
     ge#(1(x),0(y)) -> ge#(x,y)
     ge#(1(x),1(y)) -> ge#(x,y)
     ge#(#(),0(x)) -> ge#(#(),x)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    EDG Processor:
     DPs:
      ge#(0(x),0(y)) -> ge#(x,y)
      ge#(0(x),1(y)) -> ge#(y,x)
      ge#(1(x),0(y)) -> ge#(x,y)
      ge#(1(x),1(y)) -> ge#(x,y)
      ge#(#(),0(x)) -> ge#(#(),x)
     TRS:
      0(#()) -> #()
      +(x,#()) -> x
      +(#(),x) -> x
      +(0(x),0(y)) -> 0(+(x,y))
      +(0(x),1(y)) -> 1(+(x,y))
      +(1(x),0(y)) -> 1(+(x,y))
      +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
      +(+(x,y),z) -> +(x,+(y,z))
      -(#(),x) -> #()
      -(x,#()) -> x
      -(0(x),0(y)) -> 0(-(x,y))
      -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
      -(1(x),0(y)) -> 1(-(x,y))
      -(1(x),1(y)) -> 0(-(x,y))
      not(true()) -> false()
      not(false()) -> true()
      if(true(),x,y) -> x
      if(false(),x,y) -> y
      eq(#(),#()) -> true()
      eq(#(),1(y)) -> false()
      eq(1(x),#()) -> false()
      eq(#(),0(y)) -> eq(#(),y)
      eq(0(x),#()) -> eq(x,#())
      eq(1(x),1(y)) -> eq(x,y)
      eq(0(x),1(y)) -> false()
      eq(1(x),0(y)) -> false()
      eq(0(x),0(y)) -> eq(x,y)
      ge(0(x),0(y)) -> ge(x,y)
      ge(0(x),1(y)) -> not(ge(y,x))
      ge(1(x),0(y)) -> ge(x,y)
      ge(1(x),1(y)) -> ge(x,y)
      ge(x,#()) -> true()
      ge(#(),0(x)) -> ge(#(),x)
      ge(#(),1(x)) -> false()
      log(x) -> -(log'(x),1(#()))
      log'(#()) -> #()
      log'(1(x)) -> +(log'(x),1(#()))
      log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
      *(#(),x) -> #()
      *(0(x),y) -> 0(*(x,y))
      *(1(x),y) -> +(0(*(x,y)),y)
      *(*(x,y),z) -> *(x,*(y,z))
      *(x,+(y,z)) -> +(*(x,y),*(x,z))
      app(nil(),l) -> l
      app(cons(x,l1),l2) -> cons(x,app(l1,l2))
      sum(nil()) -> 0(#())
      sum(cons(x,l)) -> +(x,sum(l))
      sum(app(l1,l2)) -> +(sum(l1),sum(l2))
      prod(nil()) -> 1(#())
      prod(cons(x,l)) -> *(x,prod(l))
      prod(app(l1,l2)) -> *(prod(l1),prod(l2))
      mem(x,nil()) -> false()
      mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
      inter(x,nil()) -> nil()
      inter(nil(),x) -> nil()
      inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
      inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
      inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
      inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
      ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
      ifinter(false(),x,l1,l2) -> inter(l1,l2)
     graph:
      ge#(1(x),1(y)) -> ge#(x,y) -> ge#(0(x),0(y)) -> ge#(x,y)
      ge#(1(x),1(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> ge#(y,x)
      ge#(1(x),1(y)) -> ge#(x,y) -> ge#(1(x),0(y)) -> ge#(x,y)
      ge#(1(x),1(y)) -> ge#(x,y) -> ge#(1(x),1(y)) -> ge#(x,y)
      ge#(1(x),1(y)) -> ge#(x,y) -> ge#(#(),0(x)) -> ge#(#(),x)
      ge#(1(x),0(y)) -> ge#(x,y) -> ge#(0(x),0(y)) -> ge#(x,y)
      ge#(1(x),0(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> ge#(y,x)
      ge#(1(x),0(y)) -> ge#(x,y) -> ge#(1(x),0(y)) -> ge#(x,y)
      ge#(1(x),0(y)) -> ge#(x,y) -> ge#(1(x),1(y)) -> ge#(x,y)
      ge#(1(x),0(y)) -> ge#(x,y) -> ge#(#(),0(x)) -> ge#(#(),x)
      ge#(0(x),1(y)) -> ge#(y,x) -> ge#(0(x),0(y)) -> ge#(x,y)
      ge#(0(x),1(y)) -> ge#(y,x) -> ge#(0(x),1(y)) -> ge#(y,x)
      ge#(0(x),1(y)) -> ge#(y,x) -> ge#(1(x),0(y)) -> ge#(x,y)
      ge#(0(x),1(y)) -> ge#(y,x) -> ge#(1(x),1(y)) -> ge#(x,y)
      ge#(0(x),1(y)) -> ge#(y,x) -> ge#(#(),0(x)) -> ge#(#(),x)
      ge#(0(x),0(y)) -> ge#(x,y) -> ge#(0(x),0(y)) -> ge#(x,y)
      ge#(0(x),0(y)) -> ge#(x,y) -> ge#(0(x),1(y)) -> ge#(y,x)
      ge#(0(x),0(y)) -> ge#(x,y) -> ge#(1(x),0(y)) -> ge#(x,y)
      ge#(0(x),0(y)) -> ge#(x,y) -> ge#(1(x),1(y)) -> ge#(x,y)
      ge#(0(x),0(y)) -> ge#(x,y) -> ge#(#(),0(x)) -> ge#(#(),x)
      ge#(#(),0(x)) -> ge#(#(),x) -> ge#(#(),0(x)) -> ge#(#(),x)
     SCC Processor:
      #sccs: 2
      #rules: 5
      #arcs: 21/25
      DPs:
       ge#(1(x),1(y)) -> ge#(x,y)
       ge#(1(x),0(y)) -> ge#(x,y)
       ge#(0(x),1(y)) -> ge#(y,x)
       ge#(0(x),0(y)) -> ge#(x,y)
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
      Size-Change Termination Processor:
       DPs:
        
       TRS:
        0(#()) -> #()
        +(x,#()) -> x
        +(#(),x) -> x
        +(0(x),0(y)) -> 0(+(x,y))
        +(0(x),1(y)) -> 1(+(x,y))
        +(1(x),0(y)) -> 1(+(x,y))
        +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
        +(+(x,y),z) -> +(x,+(y,z))
        -(#(),x) -> #()
        -(x,#()) -> x
        -(0(x),0(y)) -> 0(-(x,y))
        -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
        -(1(x),0(y)) -> 1(-(x,y))
        -(1(x),1(y)) -> 0(-(x,y))
        not(true()) -> false()
        not(false()) -> true()
        if(true(),x,y) -> x
        if(false(),x,y) -> y
        eq(#(),#()) -> true()
        eq(#(),1(y)) -> false()
        eq(1(x),#()) -> false()
        eq(#(),0(y)) -> eq(#(),y)
        eq(0(x),#()) -> eq(x,#())
        eq(1(x),1(y)) -> eq(x,y)
        eq(0(x),1(y)) -> false()
        eq(1(x),0(y)) -> false()
        eq(0(x),0(y)) -> eq(x,y)
        ge(0(x),0(y)) -> ge(x,y)
        ge(0(x),1(y)) -> not(ge(y,x))
        ge(1(x),0(y)) -> ge(x,y)
        ge(1(x),1(y)) -> ge(x,y)
        ge(x,#()) -> true()
        ge(#(),0(x)) -> ge(#(),x)
        ge(#(),1(x)) -> false()
        log(x) -> -(log'(x),1(#()))
        log'(#()) -> #()
        log'(1(x)) -> +(log'(x),1(#()))
        log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
        *(#(),x) -> #()
        *(0(x),y) -> 0(*(x,y))
        *(1(x),y) -> +(0(*(x,y)),y)
        *(*(x,y),z) -> *(x,*(y,z))
        *(x,+(y,z)) -> +(*(x,y),*(x,z))
        app(nil(),l) -> l
        app(cons(x,l1),l2) -> cons(x,app(l1,l2))
        sum(nil()) -> 0(#())
        sum(cons(x,l)) -> +(x,sum(l))
        sum(app(l1,l2)) -> +(sum(l1),sum(l2))
        prod(nil()) -> 1(#())
        prod(cons(x,l)) -> *(x,prod(l))
        prod(app(l1,l2)) -> *(prod(l1),prod(l2))
        mem(x,nil()) -> false()
        mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
        inter(x,nil()) -> nil()
        inter(nil(),x) -> nil()
        inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
        inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
        inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
        inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
        ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
        ifinter(false(),x,l1,l2) -> inter(l1,l2)
       The DP: ge#(1(x),1(y)) -> ge#(x,y) has the edges:
         0 >   0
         1 >   1
       The DP: ge#(1(x),0(y)) -> ge#(x,y) has the edges:
         0 >   0
         1 >   1
       The DP: ge#(0(x),1(y)) -> ge#(y,x) has the edges:
         0 >   1
         1 >   0
       The DP: ge#(0(x),0(y)) -> ge#(x,y) has the edges:
         0 >   0
         1 >   1
       Qed
      
      DPs:
       ge#(#(),0(x)) -> ge#(#(),x)
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
      Size-Change Termination Processor:
       DPs:
        
       TRS:
        0(#()) -> #()
        +(x,#()) -> x
        +(#(),x) -> x
        +(0(x),0(y)) -> 0(+(x,y))
        +(0(x),1(y)) -> 1(+(x,y))
        +(1(x),0(y)) -> 1(+(x,y))
        +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
        +(+(x,y),z) -> +(x,+(y,z))
        -(#(),x) -> #()
        -(x,#()) -> x
        -(0(x),0(y)) -> 0(-(x,y))
        -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
        -(1(x),0(y)) -> 1(-(x,y))
        -(1(x),1(y)) -> 0(-(x,y))
        not(true()) -> false()
        not(false()) -> true()
        if(true(),x,y) -> x
        if(false(),x,y) -> y
        eq(#(),#()) -> true()
        eq(#(),1(y)) -> false()
        eq(1(x),#()) -> false()
        eq(#(),0(y)) -> eq(#(),y)
        eq(0(x),#()) -> eq(x,#())
        eq(1(x),1(y)) -> eq(x,y)
        eq(0(x),1(y)) -> false()
        eq(1(x),0(y)) -> false()
        eq(0(x),0(y)) -> eq(x,y)
        ge(0(x),0(y)) -> ge(x,y)
        ge(0(x),1(y)) -> not(ge(y,x))
        ge(1(x),0(y)) -> ge(x,y)
        ge(1(x),1(y)) -> ge(x,y)
        ge(x,#()) -> true()
        ge(#(),0(x)) -> ge(#(),x)
        ge(#(),1(x)) -> false()
        log(x) -> -(log'(x),1(#()))
        log'(#()) -> #()
        log'(1(x)) -> +(log'(x),1(#()))
        log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
        *(#(),x) -> #()
        *(0(x),y) -> 0(*(x,y))
        *(1(x),y) -> +(0(*(x,y)),y)
        *(*(x,y),z) -> *(x,*(y,z))
        *(x,+(y,z)) -> +(*(x,y),*(x,z))
        app(nil(),l) -> l
        app(cons(x,l1),l2) -> cons(x,app(l1,l2))
        sum(nil()) -> 0(#())
        sum(cons(x,l)) -> +(x,sum(l))
        sum(app(l1,l2)) -> +(sum(l1),sum(l2))
        prod(nil()) -> 1(#())
        prod(cons(x,l)) -> *(x,prod(l))
        prod(app(l1,l2)) -> *(prod(l1),prod(l2))
        mem(x,nil()) -> false()
        mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
        inter(x,nil()) -> nil()
        inter(nil(),x) -> nil()
        inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
        inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
        inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
        inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
        ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
        ifinter(false(),x,l1,l2) -> inter(l1,l2)
       The DP: ge#(#(),0(x)) -> ge#(#(),x) has the edges:
         0 >=  0
         1 >   1
       Qed
    
    DPs:
     sum#(cons(x,l)) -> sum#(l)
     sum#(app(l1,l2)) -> sum#(l2)
     sum#(app(l1,l2)) -> sum#(l1)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(sum#) = 0
     problem:
      DPs:
       
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Qed
    
    DPs:
     prod#(cons(x,l)) -> prod#(l)
     prod#(app(l1,l2)) -> prod#(l2)
     prod#(app(l1,l2)) -> prod#(l1)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(prod#) = 0
     problem:
      DPs:
       
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Qed
    
    DPs:
     *#(0(x),y) -> *#(x,y)
     *#(1(x),y) -> *#(x,y)
     *#(*(x,y),z) -> *#(y,z)
     *#(*(x,y),z) -> *#(x,*(y,z))
     *#(x,+(y,z)) -> *#(x,z)
     *#(x,+(y,z)) -> *#(x,y)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(*#) = 0
     problem:
      DPs:
       *#(x,+(y,z)) -> *#(x,z)
       *#(x,+(y,z)) -> *#(x,y)
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Subterm Criterion Processor:
      simple projection:
       pi(*#) = 1
      problem:
       DPs:
        
       TRS:
        0(#()) -> #()
        +(x,#()) -> x
        +(#(),x) -> x
        +(0(x),0(y)) -> 0(+(x,y))
        +(0(x),1(y)) -> 1(+(x,y))
        +(1(x),0(y)) -> 1(+(x,y))
        +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
        +(+(x,y),z) -> +(x,+(y,z))
        -(#(),x) -> #()
        -(x,#()) -> x
        -(0(x),0(y)) -> 0(-(x,y))
        -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
        -(1(x),0(y)) -> 1(-(x,y))
        -(1(x),1(y)) -> 0(-(x,y))
        not(true()) -> false()
        not(false()) -> true()
        if(true(),x,y) -> x
        if(false(),x,y) -> y
        eq(#(),#()) -> true()
        eq(#(),1(y)) -> false()
        eq(1(x),#()) -> false()
        eq(#(),0(y)) -> eq(#(),y)
        eq(0(x),#()) -> eq(x,#())
        eq(1(x),1(y)) -> eq(x,y)
        eq(0(x),1(y)) -> false()
        eq(1(x),0(y)) -> false()
        eq(0(x),0(y)) -> eq(x,y)
        ge(0(x),0(y)) -> ge(x,y)
        ge(0(x),1(y)) -> not(ge(y,x))
        ge(1(x),0(y)) -> ge(x,y)
        ge(1(x),1(y)) -> ge(x,y)
        ge(x,#()) -> true()
        ge(#(),0(x)) -> ge(#(),x)
        ge(#(),1(x)) -> false()
        log(x) -> -(log'(x),1(#()))
        log'(#()) -> #()
        log'(1(x)) -> +(log'(x),1(#()))
        log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
        *(#(),x) -> #()
        *(0(x),y) -> 0(*(x,y))
        *(1(x),y) -> +(0(*(x,y)),y)
        *(*(x,y),z) -> *(x,*(y,z))
        *(x,+(y,z)) -> +(*(x,y),*(x,z))
        app(nil(),l) -> l
        app(cons(x,l1),l2) -> cons(x,app(l1,l2))
        sum(nil()) -> 0(#())
        sum(cons(x,l)) -> +(x,sum(l))
        sum(app(l1,l2)) -> +(sum(l1),sum(l2))
        prod(nil()) -> 1(#())
        prod(cons(x,l)) -> *(x,prod(l))
        prod(app(l1,l2)) -> *(prod(l1),prod(l2))
        mem(x,nil()) -> false()
        mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
        inter(x,nil()) -> nil()
        inter(nil(),x) -> nil()
        inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
        inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
        inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
        inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
        ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
        ifinter(false(),x,l1,l2) -> inter(l1,l2)
      Qed
    
    DPs:
     +#(0(x),0(y)) -> +#(x,y)
     +#(0(x),1(y)) -> +#(x,y)
     +#(1(x),0(y)) -> +#(x,y)
     +#(1(x),1(y)) -> +#(x,y)
     +#(1(x),1(y)) -> +#(+(x,y),1(#()))
     +#(+(x,y),z) -> +#(y,z)
     +#(+(x,y),z) -> +#(x,+(y,z))
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    EDG Processor:
     DPs:
      +#(0(x),0(y)) -> +#(x,y)
      +#(0(x),1(y)) -> +#(x,y)
      +#(1(x),0(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(+(x,y),z) -> +#(y,z)
      +#(+(x,y),z) -> +#(x,+(y,z))
     TRS:
      0(#()) -> #()
      +(x,#()) -> x
      +(#(),x) -> x
      +(0(x),0(y)) -> 0(+(x,y))
      +(0(x),1(y)) -> 1(+(x,y))
      +(1(x),0(y)) -> 1(+(x,y))
      +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
      +(+(x,y),z) -> +(x,+(y,z))
      -(#(),x) -> #()
      -(x,#()) -> x
      -(0(x),0(y)) -> 0(-(x,y))
      -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
      -(1(x),0(y)) -> 1(-(x,y))
      -(1(x),1(y)) -> 0(-(x,y))
      not(true()) -> false()
      not(false()) -> true()
      if(true(),x,y) -> x
      if(false(),x,y) -> y
      eq(#(),#()) -> true()
      eq(#(),1(y)) -> false()
      eq(1(x),#()) -> false()
      eq(#(),0(y)) -> eq(#(),y)
      eq(0(x),#()) -> eq(x,#())
      eq(1(x),1(y)) -> eq(x,y)
      eq(0(x),1(y)) -> false()
      eq(1(x),0(y)) -> false()
      eq(0(x),0(y)) -> eq(x,y)
      ge(0(x),0(y)) -> ge(x,y)
      ge(0(x),1(y)) -> not(ge(y,x))
      ge(1(x),0(y)) -> ge(x,y)
      ge(1(x),1(y)) -> ge(x,y)
      ge(x,#()) -> true()
      ge(#(),0(x)) -> ge(#(),x)
      ge(#(),1(x)) -> false()
      log(x) -> -(log'(x),1(#()))
      log'(#()) -> #()
      log'(1(x)) -> +(log'(x),1(#()))
      log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
      *(#(),x) -> #()
      *(0(x),y) -> 0(*(x,y))
      *(1(x),y) -> +(0(*(x,y)),y)
      *(*(x,y),z) -> *(x,*(y,z))
      *(x,+(y,z)) -> +(*(x,y),*(x,z))
      app(nil(),l) -> l
      app(cons(x,l1),l2) -> cons(x,app(l1,l2))
      sum(nil()) -> 0(#())
      sum(cons(x,l)) -> +(x,sum(l))
      sum(app(l1,l2)) -> +(sum(l1),sum(l2))
      prod(nil()) -> 1(#())
      prod(cons(x,l)) -> *(x,prod(l))
      prod(app(l1,l2)) -> *(prod(l1),prod(l2))
      mem(x,nil()) -> false()
      mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
      inter(x,nil()) -> nil()
      inter(nil(),x) -> nil()
      inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
      inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
      inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
      inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
      ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
      ifinter(false(),x,l1,l2) -> inter(l1,l2)
     graph:
      +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
      +#(0(x),1(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
      +#(1(x),1(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
      +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(1(x),1(y)) -> +#(+(x,y),1(#())) ->
      +#(+(x,y),z) -> +#(y,z)
      +#(1(x),1(y)) -> +#(+(x,y),1(#())) -> +#(+(x,y),z) -> +#(x,+(y,z))
      +#(1(x),1(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
      +#(1(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(1(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
      +#(1(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
      +#(1(x),0(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
      +#(1(x),0(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
      +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
      +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
      +#(1(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(1(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
      +#(1(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
      +#(+(x,y),z) -> +#(y,z) -> +#(0(x),0(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(y,z) -> +#(0(x),1(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(y,z) -> +#(1(x),0(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(y,z) -> +#(1(x),1(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(y,z) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(+(x,y),z) -> +#(y,z) -> +#(+(x,y),z) -> +#(y,z)
      +#(+(x,y),z) -> +#(y,z) -> +#(+(x,y),z) -> +#(x,+(y,z))
      +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(0(x),0(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(0(x),1(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(1(x),0(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(1(x),1(y)) -> +#(x,y)
      +#(+(x,y),z) -> +#(x,+(y,z)) ->
      +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(+(x,y),z) -> +#(y,z)
      +#(+(x,y),z) -> +#(x,+(y,z)) -> +#(+(x,y),z) -> +#(x,+(y,z))
      +#(0(x),1(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
      +#(0(x),1(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
      +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
      +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
      +#(0(x),1(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(0(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
      +#(0(x),1(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
      +#(0(x),0(y)) -> +#(x,y) -> +#(0(x),0(y)) -> +#(x,y)
      +#(0(x),0(y)) -> +#(x,y) -> +#(0(x),1(y)) -> +#(x,y)
      +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),0(y)) -> +#(x,y)
      +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(x,y)
      +#(0(x),0(y)) -> +#(x,y) -> +#(1(x),1(y)) -> +#(+(x,y),1(#()))
      +#(0(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(y,z)
      +#(0(x),0(y)) -> +#(x,y) -> +#(+(x,y),z) -> +#(x,+(y,z))
     Usable Rule Processor:
      DPs:
       +#(0(x),0(y)) -> +#(x,y)
       +#(0(x),1(y)) -> +#(x,y)
       +#(1(x),0(y)) -> +#(x,y)
       +#(1(x),1(y)) -> +#(x,y)
       +#(1(x),1(y)) -> +#(+(x,y),1(#()))
       +#(+(x,y),z) -> +#(y,z)
       +#(+(x,y),z) -> +#(x,+(y,z))
      TRS:
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       0(#()) -> #()
      Semantic Labeling Processor:
       dimension: 1
       usable rules:
        
       interpretation:
        [1](x0) = x0 + 1,
        
        [+](x0, x1) = x0 + x1 + 1,
        
        [0](x0) = x0,
        
        [#] = 0
        labeled:
         +#
         1
         +
        usable (for model):
         +#
         0
         1
         +
         #
        argument filtering:
         pi(#) = []
         pi(0) = 0
         pi(+) = 0
         pi(1) = []
         pi(+#) = []
       precedence:
        +# ~ 1 ~ + ~ 0 ~ #
       problem:
        DPs:
         +#(0(x),0(y)) -> +#(x,y)
         +#(1(x),1(y)) -> +#(+(x,y),1(#()))
         +#(+(x,y),z) -> +#(x,+(y,z))
        TRS:
         +(x,#()) -> x
         +(#(),x) -> x
         +(0(x),0(y)) -> 0(+(x,y))
         +(0(x),1(y)) -> 1(+(x,y))
         +(1(x),0(y)) -> 1(+(x,y))
         +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
         +(+(x,y),z) -> +(x,+(y,z))
         0(#()) -> #()
       Restore Modifier:
        DPs:
         +#(0(x),0(y)) -> +#(x,y)
         +#(1(x),1(y)) -> +#(+(x,y),1(#()))
         +#(+(x,y),z) -> +#(x,+(y,z))
        TRS:
         0(#()) -> #()
         +(x,#()) -> x
         +(#(),x) -> x
         +(0(x),0(y)) -> 0(+(x,y))
         +(0(x),1(y)) -> 1(+(x,y))
         +(1(x),0(y)) -> 1(+(x,y))
         +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
         +(+(x,y),z) -> +(x,+(y,z))
         -(#(),x) -> #()
         -(x,#()) -> x
         -(0(x),0(y)) -> 0(-(x,y))
         -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
         -(1(x),0(y)) -> 1(-(x,y))
         -(1(x),1(y)) -> 0(-(x,y))
         not(true()) -> false()
         not(false()) -> true()
         if(true(),x,y) -> x
         if(false(),x,y) -> y
         eq(#(),#()) -> true()
         eq(#(),1(y)) -> false()
         eq(1(x),#()) -> false()
         eq(#(),0(y)) -> eq(#(),y)
         eq(0(x),#()) -> eq(x,#())
         eq(1(x),1(y)) -> eq(x,y)
         eq(0(x),1(y)) -> false()
         eq(1(x),0(y)) -> false()
         eq(0(x),0(y)) -> eq(x,y)
         ge(0(x),0(y)) -> ge(x,y)
         ge(0(x),1(y)) -> not(ge(y,x))
         ge(1(x),0(y)) -> ge(x,y)
         ge(1(x),1(y)) -> ge(x,y)
         ge(x,#()) -> true()
         ge(#(),0(x)) -> ge(#(),x)
         ge(#(),1(x)) -> false()
         log(x) -> -(log'(x),1(#()))
         log'(#()) -> #()
         log'(1(x)) -> +(log'(x),1(#()))
         log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
         *(#(),x) -> #()
         *(0(x),y) -> 0(*(x,y))
         *(1(x),y) -> +(0(*(x,y)),y)
         *(*(x,y),z) -> *(x,*(y,z))
         *(x,+(y,z)) -> +(*(x,y),*(x,z))
         app(nil(),l) -> l
         app(cons(x,l1),l2) -> cons(x,app(l1,l2))
         sum(nil()) -> 0(#())
         sum(cons(x,l)) -> +(x,sum(l))
         sum(app(l1,l2)) -> +(sum(l1),sum(l2))
         prod(nil()) -> 1(#())
         prod(cons(x,l)) -> *(x,prod(l))
         prod(app(l1,l2)) -> *(prod(l1),prod(l2))
         mem(x,nil()) -> false()
         mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
         inter(x,nil()) -> nil()
         inter(nil(),x) -> nil()
         inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
         inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
         inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
         inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
         ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
         ifinter(false(),x,l1,l2) -> inter(l1,l2)
        Usable Rule Processor:
         DPs:
          +#(0(x),0(y)) -> +#(x,y)
          +#(1(x),1(y)) -> +#(+(x,y),1(#()))
          +#(+(x,y),z) -> +#(x,+(y,z))
         TRS:
          +(x,#()) -> x
          +(#(),x) -> x
          +(0(x),0(y)) -> 0(+(x,y))
          +(0(x),1(y)) -> 1(+(x,y))
          +(1(x),0(y)) -> 1(+(x,y))
          +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
          +(+(x,y),z) -> +(x,+(y,z))
          0(#()) -> #()
         Semantic Labeling Processor:
          dimension: 1
          usable rules:
           
          interpretation:
           [1](x0) = x0 + 1,
           
           [+](x0, x1) = x0 + x1,
           
           [0](x0) = x0,
           
           [#] = 0
           labeled:
            +#
            +
           usable (for model):
            +#
            0
            1
            +
            #
           argument filtering:
            pi(#) = []
            pi(0) = 0
            pi(+) = 0
            pi(1) = 0
            pi(+#) = []
          precedence:
           +# ~ 1 ~ + ~ 0 ~ #
          problem:
           DPs:
            +#(0(x),0(y)) -> +#(x,y)
            +#(+(x,y),z) -> +#(x,+(y,z))
           TRS:
            +(x,#()) -> x
            +(#(),x) -> x
            +(0(x),0(y)) -> 0(+(x,y))
            +(0(x),1(y)) -> 1(+(x,y))
            +(1(x),0(y)) -> 1(+(x,y))
            +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
            +(+(x,y),z) -> +(x,+(y,z))
            0(#()) -> #()
          Restore Modifier:
           DPs:
            +#(0(x),0(y)) -> +#(x,y)
            +#(+(x,y),z) -> +#(x,+(y,z))
           TRS:
            0(#()) -> #()
            +(x,#()) -> x
            +(#(),x) -> x
            +(0(x),0(y)) -> 0(+(x,y))
            +(0(x),1(y)) -> 1(+(x,y))
            +(1(x),0(y)) -> 1(+(x,y))
            +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
            +(+(x,y),z) -> +(x,+(y,z))
            -(#(),x) -> #()
            -(x,#()) -> x
            -(0(x),0(y)) -> 0(-(x,y))
            -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
            -(1(x),0(y)) -> 1(-(x,y))
            -(1(x),1(y)) -> 0(-(x,y))
            not(true()) -> false()
            not(false()) -> true()
            if(true(),x,y) -> x
            if(false(),x,y) -> y
            eq(#(),#()) -> true()
            eq(#(),1(y)) -> false()
            eq(1(x),#()) -> false()
            eq(#(),0(y)) -> eq(#(),y)
            eq(0(x),#()) -> eq(x,#())
            eq(1(x),1(y)) -> eq(x,y)
            eq(0(x),1(y)) -> false()
            eq(1(x),0(y)) -> false()
            eq(0(x),0(y)) -> eq(x,y)
            ge(0(x),0(y)) -> ge(x,y)
            ge(0(x),1(y)) -> not(ge(y,x))
            ge(1(x),0(y)) -> ge(x,y)
            ge(1(x),1(y)) -> ge(x,y)
            ge(x,#()) -> true()
            ge(#(),0(x)) -> ge(#(),x)
            ge(#(),1(x)) -> false()
            log(x) -> -(log'(x),1(#()))
            log'(#()) -> #()
            log'(1(x)) -> +(log'(x),1(#()))
            log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
            *(#(),x) -> #()
            *(0(x),y) -> 0(*(x,y))
            *(1(x),y) -> +(0(*(x,y)),y)
            *(*(x,y),z) -> *(x,*(y,z))
            *(x,+(y,z)) -> +(*(x,y),*(x,z))
            app(nil(),l) -> l
            app(cons(x,l1),l2) -> cons(x,app(l1,l2))
            sum(nil()) -> 0(#())
            sum(cons(x,l)) -> +(x,sum(l))
            sum(app(l1,l2)) -> +(sum(l1),sum(l2))
            prod(nil()) -> 1(#())
            prod(cons(x,l)) -> *(x,prod(l))
            prod(app(l1,l2)) -> *(prod(l1),prod(l2))
            mem(x,nil()) -> false()
            mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
            inter(x,nil()) -> nil()
            inter(nil(),x) -> nil()
            inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
            inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
            inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
            inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
            ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
            ifinter(false(),x,l1,l2) -> inter(l1,l2)
           Size-Change Termination Processor:
            DPs:
             
            TRS:
             0(#()) -> #()
             +(x,#()) -> x
             +(#(),x) -> x
             +(0(x),0(y)) -> 0(+(x,y))
             +(0(x),1(y)) -> 1(+(x,y))
             +(1(x),0(y)) -> 1(+(x,y))
             +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
             +(+(x,y),z) -> +(x,+(y,z))
             -(#(),x) -> #()
             -(x,#()) -> x
             -(0(x),0(y)) -> 0(-(x,y))
             -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
             -(1(x),0(y)) -> 1(-(x,y))
             -(1(x),1(y)) -> 0(-(x,y))
             not(true()) -> false()
             not(false()) -> true()
             if(true(),x,y) -> x
             if(false(),x,y) -> y
             eq(#(),#()) -> true()
             eq(#(),1(y)) -> false()
             eq(1(x),#()) -> false()
             eq(#(),0(y)) -> eq(#(),y)
             eq(0(x),#()) -> eq(x,#())
             eq(1(x),1(y)) -> eq(x,y)
             eq(0(x),1(y)) -> false()
             eq(1(x),0(y)) -> false()
             eq(0(x),0(y)) -> eq(x,y)
             ge(0(x),0(y)) -> ge(x,y)
             ge(0(x),1(y)) -> not(ge(y,x))
             ge(1(x),0(y)) -> ge(x,y)
             ge(1(x),1(y)) -> ge(x,y)
             ge(x,#()) -> true()
             ge(#(),0(x)) -> ge(#(),x)
             ge(#(),1(x)) -> false()
             log(x) -> -(log'(x),1(#()))
             log'(#()) -> #()
             log'(1(x)) -> +(log'(x),1(#()))
             log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
             *(#(),x) -> #()
             *(0(x),y) -> 0(*(x,y))
             *(1(x),y) -> +(0(*(x,y)),y)
             *(*(x,y),z) -> *(x,*(y,z))
             *(x,+(y,z)) -> +(*(x,y),*(x,z))
             app(nil(),l) -> l
             app(cons(x,l1),l2) -> cons(x,app(l1,l2))
             sum(nil()) -> 0(#())
             sum(cons(x,l)) -> +(x,sum(l))
             sum(app(l1,l2)) -> +(sum(l1),sum(l2))
             prod(nil()) -> 1(#())
             prod(cons(x,l)) -> *(x,prod(l))
             prod(app(l1,l2)) -> *(prod(l1),prod(l2))
             mem(x,nil()) -> false()
             mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
             inter(x,nil()) -> nil()
             inter(nil(),x) -> nil()
             inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
             inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
             inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
             inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
             ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
             ifinter(false(),x,l1,l2) -> inter(l1,l2)
            The DP: +#(0(x),0(y)) -> +#(x,y) has the edges:
              0 >   0
              1 >   1
            The DP: +#(+(x,y),z) -> +#(x,+(y,z)) has the edges:
              0 >   0
            Qed
    
    DPs:
     ifinter#(false(),x,l1,l2) -> inter#(l1,l2)
     inter#(app(l1,l2),l3) -> inter#(l2,l3)
     inter#(app(l1,l2),l3) -> inter#(l1,l3)
     inter#(l1,app(l2,l3)) -> inter#(l1,l3)
     inter#(l1,app(l2,l3)) -> inter#(l1,l2)
     inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2)
     ifinter#(true(),x,l1,l2) -> inter#(l1,l2)
     inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Size-Change Termination Processor:
     DPs:
      
     TRS:
      0(#()) -> #()
      +(x,#()) -> x
      +(#(),x) -> x
      +(0(x),0(y)) -> 0(+(x,y))
      +(0(x),1(y)) -> 1(+(x,y))
      +(1(x),0(y)) -> 1(+(x,y))
      +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
      +(+(x,y),z) -> +(x,+(y,z))
      -(#(),x) -> #()
      -(x,#()) -> x
      -(0(x),0(y)) -> 0(-(x,y))
      -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
      -(1(x),0(y)) -> 1(-(x,y))
      -(1(x),1(y)) -> 0(-(x,y))
      not(true()) -> false()
      not(false()) -> true()
      if(true(),x,y) -> x
      if(false(),x,y) -> y
      eq(#(),#()) -> true()
      eq(#(),1(y)) -> false()
      eq(1(x),#()) -> false()
      eq(#(),0(y)) -> eq(#(),y)
      eq(0(x),#()) -> eq(x,#())
      eq(1(x),1(y)) -> eq(x,y)
      eq(0(x),1(y)) -> false()
      eq(1(x),0(y)) -> false()
      eq(0(x),0(y)) -> eq(x,y)
      ge(0(x),0(y)) -> ge(x,y)
      ge(0(x),1(y)) -> not(ge(y,x))
      ge(1(x),0(y)) -> ge(x,y)
      ge(1(x),1(y)) -> ge(x,y)
      ge(x,#()) -> true()
      ge(#(),0(x)) -> ge(#(),x)
      ge(#(),1(x)) -> false()
      log(x) -> -(log'(x),1(#()))
      log'(#()) -> #()
      log'(1(x)) -> +(log'(x),1(#()))
      log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
      *(#(),x) -> #()
      *(0(x),y) -> 0(*(x,y))
      *(1(x),y) -> +(0(*(x,y)),y)
      *(*(x,y),z) -> *(x,*(y,z))
      *(x,+(y,z)) -> +(*(x,y),*(x,z))
      app(nil(),l) -> l
      app(cons(x,l1),l2) -> cons(x,app(l1,l2))
      sum(nil()) -> 0(#())
      sum(cons(x,l)) -> +(x,sum(l))
      sum(app(l1,l2)) -> +(sum(l1),sum(l2))
      prod(nil()) -> 1(#())
      prod(cons(x,l)) -> *(x,prod(l))
      prod(app(l1,l2)) -> *(prod(l1),prod(l2))
      mem(x,nil()) -> false()
      mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
      inter(x,nil()) -> nil()
      inter(nil(),x) -> nil()
      inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
      inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
      inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
      inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
      ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
      ifinter(false(),x,l1,l2) -> inter(l1,l2)
     The DP: ifinter#(false(),x,l1,l2) -> inter#(l1,l2) has the edges:
       2 >=  0
       3 >=  1
     The DP: inter#(app(l1,l2),l3) -> inter#(l2,l3) has the edges:
       0 >   0
       1 >=  1
     The DP: inter#(app(l1,l2),l3) -> inter#(l1,l3) has the edges:
       0 >   0
       1 >=  1
     The DP: inter#(l1,app(l2,l3)) -> inter#(l1,l3) has the edges:
       0 >=  0
       1 >   1
     The DP: inter#(l1,app(l2,l3)) -> inter#(l1,l2) has the edges:
       0 >=  0
       1 >   1
     The DP: inter#(cons(x,l1),l2) -> ifinter#(mem(x,l2),x,l1,l2) has the edges:
       0 >   2
       0 >   1
       1 >=  3
     The DP: ifinter#(true(),x,l1,l2) -> inter#(l1,l2) has the edges:
       2 >=  0
       3 >=  1
     The DP: inter#(l1,cons(x,l2)) -> ifinter#(mem(x,l1),x,l2,l1) has the edges:
       0 >=  3
       1 >   2
       1 >   1
     Qed
    
    DPs:
     mem#(x,cons(y,l)) -> mem#(x,l)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(mem#) = 1
     problem:
      DPs:
       
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Qed
    
    DPs:
     eq#(#(),0(y)) -> eq#(#(),y)
     eq#(0(x),#()) -> eq#(x,#())
     eq#(1(x),1(y)) -> eq#(x,y)
     eq#(0(x),0(y)) -> eq#(x,y)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(eq#) = 0
     problem:
      DPs:
       eq#(#(),0(y)) -> eq#(#(),y)
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Subterm Criterion Processor:
      simple projection:
       pi(eq#) = 1
      problem:
       DPs:
        
       TRS:
        0(#()) -> #()
        +(x,#()) -> x
        +(#(),x) -> x
        +(0(x),0(y)) -> 0(+(x,y))
        +(0(x),1(y)) -> 1(+(x,y))
        +(1(x),0(y)) -> 1(+(x,y))
        +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
        +(+(x,y),z) -> +(x,+(y,z))
        -(#(),x) -> #()
        -(x,#()) -> x
        -(0(x),0(y)) -> 0(-(x,y))
        -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
        -(1(x),0(y)) -> 1(-(x,y))
        -(1(x),1(y)) -> 0(-(x,y))
        not(true()) -> false()
        not(false()) -> true()
        if(true(),x,y) -> x
        if(false(),x,y) -> y
        eq(#(),#()) -> true()
        eq(#(),1(y)) -> false()
        eq(1(x),#()) -> false()
        eq(#(),0(y)) -> eq(#(),y)
        eq(0(x),#()) -> eq(x,#())
        eq(1(x),1(y)) -> eq(x,y)
        eq(0(x),1(y)) -> false()
        eq(1(x),0(y)) -> false()
        eq(0(x),0(y)) -> eq(x,y)
        ge(0(x),0(y)) -> ge(x,y)
        ge(0(x),1(y)) -> not(ge(y,x))
        ge(1(x),0(y)) -> ge(x,y)
        ge(1(x),1(y)) -> ge(x,y)
        ge(x,#()) -> true()
        ge(#(),0(x)) -> ge(#(),x)
        ge(#(),1(x)) -> false()
        log(x) -> -(log'(x),1(#()))
        log'(#()) -> #()
        log'(1(x)) -> +(log'(x),1(#()))
        log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
        *(#(),x) -> #()
        *(0(x),y) -> 0(*(x,y))
        *(1(x),y) -> +(0(*(x,y)),y)
        *(*(x,y),z) -> *(x,*(y,z))
        *(x,+(y,z)) -> +(*(x,y),*(x,z))
        app(nil(),l) -> l
        app(cons(x,l1),l2) -> cons(x,app(l1,l2))
        sum(nil()) -> 0(#())
        sum(cons(x,l)) -> +(x,sum(l))
        sum(app(l1,l2)) -> +(sum(l1),sum(l2))
        prod(nil()) -> 1(#())
        prod(cons(x,l)) -> *(x,prod(l))
        prod(app(l1,l2)) -> *(prod(l1),prod(l2))
        mem(x,nil()) -> false()
        mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
        inter(x,nil()) -> nil()
        inter(nil(),x) -> nil()
        inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
        inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
        inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
        inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
        ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
        ifinter(false(),x,l1,l2) -> inter(l1,l2)
      Qed
    
    DPs:
     app#(cons(x,l1),l2) -> app#(l1,l2)
    TRS:
     0(#()) -> #()
     +(x,#()) -> x
     +(#(),x) -> x
     +(0(x),0(y)) -> 0(+(x,y))
     +(0(x),1(y)) -> 1(+(x,y))
     +(1(x),0(y)) -> 1(+(x,y))
     +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
     +(+(x,y),z) -> +(x,+(y,z))
     -(#(),x) -> #()
     -(x,#()) -> x
     -(0(x),0(y)) -> 0(-(x,y))
     -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
     -(1(x),0(y)) -> 1(-(x,y))
     -(1(x),1(y)) -> 0(-(x,y))
     not(true()) -> false()
     not(false()) -> true()
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     eq(#(),#()) -> true()
     eq(#(),1(y)) -> false()
     eq(1(x),#()) -> false()
     eq(#(),0(y)) -> eq(#(),y)
     eq(0(x),#()) -> eq(x,#())
     eq(1(x),1(y)) -> eq(x,y)
     eq(0(x),1(y)) -> false()
     eq(1(x),0(y)) -> false()
     eq(0(x),0(y)) -> eq(x,y)
     ge(0(x),0(y)) -> ge(x,y)
     ge(0(x),1(y)) -> not(ge(y,x))
     ge(1(x),0(y)) -> ge(x,y)
     ge(1(x),1(y)) -> ge(x,y)
     ge(x,#()) -> true()
     ge(#(),0(x)) -> ge(#(),x)
     ge(#(),1(x)) -> false()
     log(x) -> -(log'(x),1(#()))
     log'(#()) -> #()
     log'(1(x)) -> +(log'(x),1(#()))
     log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
     *(#(),x) -> #()
     *(0(x),y) -> 0(*(x,y))
     *(1(x),y) -> +(0(*(x,y)),y)
     *(*(x,y),z) -> *(x,*(y,z))
     *(x,+(y,z)) -> +(*(x,y),*(x,z))
     app(nil(),l) -> l
     app(cons(x,l1),l2) -> cons(x,app(l1,l2))
     sum(nil()) -> 0(#())
     sum(cons(x,l)) -> +(x,sum(l))
     sum(app(l1,l2)) -> +(sum(l1),sum(l2))
     prod(nil()) -> 1(#())
     prod(cons(x,l)) -> *(x,prod(l))
     prod(app(l1,l2)) -> *(prod(l1),prod(l2))
     mem(x,nil()) -> false()
     mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
     inter(x,nil()) -> nil()
     inter(nil(),x) -> nil()
     inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
     inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
     inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
     inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
     ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
     ifinter(false(),x,l1,l2) -> inter(l1,l2)
    Subterm Criterion Processor:
     simple projection:
      pi(app#) = 0
     problem:
      DPs:
       
      TRS:
       0(#()) -> #()
       +(x,#()) -> x
       +(#(),x) -> x
       +(0(x),0(y)) -> 0(+(x,y))
       +(0(x),1(y)) -> 1(+(x,y))
       +(1(x),0(y)) -> 1(+(x,y))
       +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
       +(+(x,y),z) -> +(x,+(y,z))
       -(#(),x) -> #()
       -(x,#()) -> x
       -(0(x),0(y)) -> 0(-(x,y))
       -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
       -(1(x),0(y)) -> 1(-(x,y))
       -(1(x),1(y)) -> 0(-(x,y))
       not(true()) -> false()
       not(false()) -> true()
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       eq(#(),#()) -> true()
       eq(#(),1(y)) -> false()
       eq(1(x),#()) -> false()
       eq(#(),0(y)) -> eq(#(),y)
       eq(0(x),#()) -> eq(x,#())
       eq(1(x),1(y)) -> eq(x,y)
       eq(0(x),1(y)) -> false()
       eq(1(x),0(y)) -> false()
       eq(0(x),0(y)) -> eq(x,y)
       ge(0(x),0(y)) -> ge(x,y)
       ge(0(x),1(y)) -> not(ge(y,x))
       ge(1(x),0(y)) -> ge(x,y)
       ge(1(x),1(y)) -> ge(x,y)
       ge(x,#()) -> true()
       ge(#(),0(x)) -> ge(#(),x)
       ge(#(),1(x)) -> false()
       log(x) -> -(log'(x),1(#()))
       log'(#()) -> #()
       log'(1(x)) -> +(log'(x),1(#()))
       log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
       *(#(),x) -> #()
       *(0(x),y) -> 0(*(x,y))
       *(1(x),y) -> +(0(*(x,y)),y)
       *(*(x,y),z) -> *(x,*(y,z))
       *(x,+(y,z)) -> +(*(x,y),*(x,z))
       app(nil(),l) -> l
       app(cons(x,l1),l2) -> cons(x,app(l1,l2))
       sum(nil()) -> 0(#())
       sum(cons(x,l)) -> +(x,sum(l))
       sum(app(l1,l2)) -> +(sum(l1),sum(l2))
       prod(nil()) -> 1(#())
       prod(cons(x,l)) -> *(x,prod(l))
       prod(app(l1,l2)) -> *(prod(l1),prod(l2))
       mem(x,nil()) -> false()
       mem(x,cons(y,l)) -> if(eq(x,y),true(),mem(x,l))
       inter(x,nil()) -> nil()
       inter(nil(),x) -> nil()
       inter(app(l1,l2),l3) -> app(inter(l1,l3),inter(l2,l3))
       inter(l1,app(l2,l3)) -> app(inter(l1,l2),inter(l1,l3))
       inter(cons(x,l1),l2) -> ifinter(mem(x,l2),x,l1,l2)
       inter(l1,cons(x,l2)) -> ifinter(mem(x,l1),x,l2,l1)
       ifinter(true(),x,l1,l2) -> cons(x,inter(l1,l2))
       ifinter(false(),x,l1,l2) -> inter(l1,l2)
     Qed